@bfun-bot/cli 1.0.5

package/README.md

@@ -0,0 +1,93 @@
+# BFunBot CLI
+
+Deploy tokens, check balances, and manage your AI agent from the terminal.
+
+## Installation
+
+```bash
+npm install -g @bfun_bot/cli
+```
+
+## Quick Start
+
+```bash
+# Authenticate
+bfunbot login
+
+# Create a token
+bfunbot token create --name "My Token" --symbol MYT
+
+# Check balances
+bfunbot balances
+
+# Check fee earnings
+bfunbot fees
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `bfunbot login` | Authenticate with your BFunBot API key |
+| `bfunbot logout` | Clear stored credentials |
+| `bfunbot whoami` | Show current user info |
+| `bfunbot token create` | Create a new token |
+| `bfunbot token info <address>` | Get token details |
+| `bfunbot tokens created` | List tokens you've created |
+| `bfunbot status <jobId>` | Check job status |
+| `bfunbot balances` | Show wallet balances (BSC) |
+| `bfunbot quota` | Show daily API quota |
+| `bfunbot fees` | Check fee earnings summary |
+| `bfunbot fees --platform flap` | Per-platform fee breakdown |
+| `bfunbot llm models` | List available LLM models |
+| `bfunbot llm credits` | Check BFun.bot Credits balance |
+| `bfunbot llm reload` | Reload credits from trading wallet |
+| `bfunbot llm setup openclaw` | Configure OpenClaw integration |
+| `bfunbot skills` | List agent capabilities |
+| `bfunbot config get` | Show current config |
+| `bfunbot config set` | Set a config value |
+| `bfunbot about` | About BFunBot CLI |
+
+## Authentication
+
+Get your API key at [bfun.bot/settings/api-keys](https://bfun.bot/settings/api-keys).
+
+```bash
+bfunbot login --api-key bfbot_...
+# or open browser
+bfunbot login --url
+```
+
+Config is stored at `~/.bfunbot/config.json` (permissions: 0600).
+
+You can also set `BFUN_API_KEY` environment variable instead of storing a key.
+
+## Networks
+
+BSC (BNB Chain) only — flap and fourmeme platforms.
+
+## LLM Gateway
+
+The BFun LLM Gateway gives your agent access to frontier AI models (Claude, GPT, Gemini), billed from your BFun.bot Credits balance.
+
+```bash
+# Set up OpenClaw integration
+bfunbot llm setup openclaw --install
+
+# Check credit balance
+bfunbot llm credits
+
+# Reload credits from trading wallet
+bfunbot llm reload
+```
+
+## Global Options
+
+- `--json` — Machine-readable JSON output
+- `--debug` — Verbose HTTP request/response logging
+
+## Links
+
+- Website: [bfun.bot](https://bfun.bot)
+- Docs: [bfun.bot/docs/agent](https://bfun.bot/docs/agent)
+- GitHub: [github.com/BFunBot](https://github.com/BFunBot)

package/bin/bfunbot.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/commands/about.d.ts

@@ -0,0 +1,5 @@
+/**
+ * bfunbot about — branded info card
+ */
+import { Command } from 'commander';
+export declare function registerAbout(program: Command): void;

package/dist/commands/about.js

@@ -0,0 +1,62 @@
+import chalk from 'chalk';
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+function getVersion() {
+    try {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8'));
+        return pkg.version || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export function registerAbout(program) {
+    program
+        .command('about')
+        .description('About BFunBot CLI')
+        .action(() => {
+        const version = getVersion();
+        const W = 43; // inner width between ║ borders
+        function pad(text, displayWidth) {
+            const dw = displayWidth ?? text.length;
+            const padding = W - dw;
+            return text + ' '.repeat(Math.max(0, padding));
+        }
+        const lines = [
+            '',
+            '   B F U N . B O T',
+            '',
+            '   Deploy tokens. Earn fees.',
+            '   Self-fund your AI agent.',
+            '',
+            `   Version    ${version}`,
+            '   Website    bfun.bot',
+            '   Docs       bfun.bot/docs/agent',
+            '   GitHub     github.com/BFunBot',
+            '',
+            '   BSC',
+            '',
+        ];
+        console.log();
+        console.log(chalk.cyan(`  ╔${'═'.repeat(W)}╗`));
+        for (const line of lines) {
+            console.log(chalk.cyan('  ║') + pad(line) + chalk.cyan('║'));
+        }
+        console.log(chalk.cyan(`  ╚${'═'.repeat(W)}╝`));
+        console.log();
+        // Mark as welcomed
+        try {
+            const bfunDir = join(homedir(), '.bfunbot');
+            const marker = join(bfunDir, '.welcomed');
+            if (!existsSync(marker)) {
+                if (!existsSync(bfunDir))
+                    mkdirSync(bfunDir, { recursive: true });
+                writeFileSync(marker, new Date().toISOString());
+            }
+        }
+        catch { }
+    });
+}

package/dist/commands/balances.d.ts

@@ -0,0 +1,5 @@
+/**
+ * bfunbot balances — BSC only
+ */
+import { Command } from 'commander';
+export declare function registerBalances(program: Command): void;

package/dist/commands/balances.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { agent, handleApiError } from '../lib/api.js';
+import { fmtBalance, shortAddr } from '../lib/display.js';
+function printWallet(label, slot) {
+    if (!slot.address) {
+        console.log(`  ${chalk.dim(label + ':')}  ${chalk.dim('Not configured')}`);
+        return;
+    }
+    console.log(`  ${chalk.bold(label)}  ${chalk.dim(shortAddr(slot.address))}`);
+    const balances = [
+        ['BNB (BSC)', slot.balance_bnb, slot.bnb_error],
+        ['USDT (BSC)', slot.balance_usdt_bsc, slot.usdt_bsc_error],
+    ];
+    for (const [name, value, error] of balances) {
+        if (error) {
+            console.log(`    ${name.padEnd(14)} ${chalk.red('error')}`);
+        }
+        else if (name === 'BNB (BSC)' || (value && parseFloat(value) > 0)) {
+            const symbol = name.split(' ')[0];
+            console.log(`    ${name.padEnd(14)} ${fmtBalance(value, symbol)}`);
+        }
+    }
+    console.log();
+}
+export function registerBalances(program) {
+    program
+        .command('balances')
+        .description('Show wallet balances (BSC)')
+        .action(async (_, cmd) => {
+        try {
+            const res = await agent.walletBalance();
+            const isJson = cmd.optsWithGlobals().json;
+            if (isJson) {
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            console.log();
+            console.log(chalk.bold.cyan('Wallet Balances'));
+            console.log(chalk.dim('─'.repeat(40)));
+            console.log();
+            printWallet('EVM Main', res.evm_main);
+            printWallet('EVM Trading', res.evm_trading);
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * bfunbot config get / bfun config set
+ */
+import { Command } from 'commander';
+export declare function registerConfig(program: Command): void;

package/dist/commands/config.js

@@ -0,0 +1,53 @@
+import chalk from 'chalk';
+import { readConfig, setConfigValue, CONFIG_PATH } from '../lib/config.js';
+const VALID_KEYS = ['apiKey'];
+function maskKey(key) {
+    if (key.length <= 8)
+        return '***';
+    return key.slice(0, 6) + '...' + key.slice(-4);
+}
+export function registerConfig(program) {
+    const configCmd = program
+        .command('config')
+        .description('Read or write CLI configuration');
+    configCmd
+        .command('get [key]')
+        .description('Show config values')
+        .action((key) => {
+        const config = readConfig();
+        if (key) {
+            if (!VALID_KEYS.includes(key)) {
+                console.error(`Error: Unknown key '${key}'. Valid keys: ${VALID_KEYS.join(', ')}`);
+                process.exit(1);
+            }
+            const value = config[key];
+            if (value) {
+                console.log(key === 'apiKey' ? maskKey(value) : value);
+            }
+            else {
+                console.log(chalk.dim('(not set)'));
+            }
+            return;
+        }
+        // Show all
+        console.log();
+        console.log(chalk.bold.cyan('Configuration'));
+        console.log(chalk.dim('─'.repeat(40)));
+        console.log(`  ${chalk.dim('File:')}    ${CONFIG_PATH}`);
+        console.log(`  ${chalk.dim('apiKey:')}  ${config.apiKey ? maskKey(config.apiKey) : chalk.dim('(not set)')}`);
+        console.log(`  ${chalk.dim('apiUrl:')}  ${'https://api.bfun.bot'}`);
+        console.log(`  ${chalk.dim('llmUrl:')}  ${'https://llm.bfun.bot/v1'}`);
+        console.log();
+    });
+    configCmd
+        .command('set <key> <value>')
+        .description('Set a config value (apiKey)')
+        .action((key, value) => {
+        if (!VALID_KEYS.includes(key)) {
+            console.error(`Error: Unknown key '${key}'. Valid keys: ${VALID_KEYS.join(', ')}`);
+            process.exit(1);
+        }
+        setConfigValue(key, value);
+        console.log(chalk.green('✓') + ` ${key} updated`);
+    });
+}

package/dist/commands/fees.d.ts

@@ -0,0 +1,7 @@
+/**
+ * bfunbot fees                          — summary
+ * bfunbot fees --platform flap          — per-platform breakdown
+ * bfunbot fees --token <addr>           — single token fee detail
+ */
+import { Command } from 'commander';
+export declare function registerFees(program: Command): void;

package/dist/commands/fees.js

@@ -0,0 +1,99 @@
+import chalk from 'chalk';
+import { agent, handleApiError } from '../lib/api.js';
+import { fmtBalance, printTable } from '../lib/display.js';
+const VALID_PLATFORMS = ['flap', 'fourmeme'];
+// ─── Display Helpers ─────────────────────────────────────
+function printSummary(res) {
+    console.log();
+    console.log(chalk.bold.cyan('Fee Earnings Summary'));
+    console.log(chalk.dim('─'.repeat(44)));
+    console.log();
+    console.log(`  ${chalk.bold('BSC (BNB Chain)')}  ${chalk.dim(res.bsc.token_count + ' tokens')}`);
+    console.log(`    ${'Total Earned'.padEnd(22)} ${fmtBalance(res.bsc.total_earned_bnb.toString(), 'BNB')}`);
+    console.log();
+}
+function printEarnings(res) {
+    console.log();
+    console.log(chalk.bold.cyan(`Fee Earnings · BSC`));
+    console.log(chalk.dim('─'.repeat(44)));
+    console.log();
+    printTable(['Platform', 'Earned', 'Tokens'], [
+        ['flap', fmtBalance(res.flap.total_earned_bnb.toString(), 'BNB'), res.flap.earning_token_count.toString()],
+        ['fourmeme', fmtBalance(res.fourmeme.total_earned_bnb.toString(), 'BNB'), res.fourmeme.earning_token_count.toString()],
+    ]);
+}
+function printToken(res) {
+    if ('supported' in res && res.supported === false) {
+        console.log();
+        console.log(chalk.yellow('⚠') + '  ' + res.message);
+        console.log();
+        return;
+    }
+    const bsc = res;
+    console.log();
+    console.log(chalk.bold.cyan('Token Fee Earnings'));
+    console.log(chalk.dim('─'.repeat(44)));
+    console.log();
+    console.log(`  ${'Token'.padEnd(14)} ${bsc.token_name} (${bsc.token_symbol})`);
+    console.log(`  ${'Address'.padEnd(14)} ${chalk.dim(bsc.token_address)}`);
+    console.log(`  ${'Platform'.padEnd(14)} ${bsc.platform}`);
+    console.log(`  ${'Earned'.padEnd(14)} ${fmtBalance(bsc.earned_bnb.toString(), 'BNB')}`);
+    console.log();
+}
+// ─── Command Registration ─────────────────────────────────
+export function registerFees(program) {
+    program
+        .command('fees')
+        .description('Check fee earnings (summary, per-platform, or per-token)')
+        .option('--platform <platform>', 'Platform: flap or fourmeme')
+        .option('--token <address>', 'Token contract address')
+        .action(async (opts, cmd) => {
+        const isJson = cmd.optsWithGlobals().json;
+        try {
+            // Per-token: requires --platform and --token
+            if (opts.token) {
+                const platform = opts.platform;
+                if (!platform) {
+                    console.error(chalk.red('Error:') + ' --platform is required with --token. Use: bfunbot fees --platform flap --token <address>');
+                    process.exit(1);
+                }
+                if (!VALID_PLATFORMS.includes(platform)) {
+                    console.error(chalk.red('Error:') + ` Platform must be one of: ${VALID_PLATFORMS.join(', ')}`);
+                    process.exit(1);
+                }
+                const res = await agent.feesToken('bsc', platform, opts.token);
+                if (isJson) {
+                    console.log(JSON.stringify(res, null, 2));
+                    return;
+                }
+                printToken(res);
+                return;
+            }
+            // Per-platform breakdown
+            if (opts.platform) {
+                if (!VALID_PLATFORMS.includes(opts.platform)) {
+                    console.error(chalk.red('Error:') + ` Platform must be one of: ${VALID_PLATFORMS.join(', ')}`);
+                    process.exit(1);
+                }
+                // Show full breakdown (both platforms) — the platform flag is for future filtering
+                const res = await agent.feesEarnings('bsc');
+                if (isJson) {
+                    console.log(JSON.stringify(res, null, 2));
+                    return;
+                }
+                printEarnings(res);
+                return;
+            }
+            // Default: summary
+            const res = await agent.feesSummary();
+            if (isJson) {
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            printSummary(res);
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+}

package/dist/commands/llm.d.ts

@@ -0,0 +1,5 @@
+/**
+ * bfunbot llm models / bfun llm credits / bfun llm setup <target>
+ */
+import { Command } from 'commander';
+export declare function registerLlm(program: Command): void;

package/dist/commands/llm.js

@@ -0,0 +1,216 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { agent, llm, handleApiError } from '../lib/api.js';
+import { readConfig } from '../lib/config.js';
+import { printCard, success } from '../lib/display.js';
+export function registerLlm(program) {
+    const llmCmd = program
+        .command('llm')
+        .description('LLM Gateway commands');
+    // ── llm models ────────────────────────────────────────
+    llmCmd
+        .command('models')
+        .description('List available LLM models')
+        .action(async (_, cmd) => {
+        try {
+            const res = await llm.models();
+            const isJson = cmd.optsWithGlobals().json;
+            if (isJson) {
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const models = res.models || [];
+            if (models.length === 0) {
+                console.log('\nNo models available.\n');
+                return;
+            }
+            console.log();
+            console.log(chalk.bold.cyan(`Available Models (${models.length})`));
+            console.log(chalk.dim('─'.repeat(40)));
+            for (const modelId of models) {
+                console.log(`  ${chalk.bold(modelId)}`);
+            }
+            console.log();
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+    // ── llm credits ───────────────────────────────────────
+    llmCmd
+        .command('credits')
+        .description('Check your BFun.bot Credits balance')
+        .action(async (_, cmd) => {
+        try {
+            const res = await agent.creditBalance();
+            const isJson = cmd.optsWithGlobals().json;
+            if (isJson) {
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            printCard('BFun.bot Credits', [
+                ['Balance', `$${res.balance_usd}`],
+            ]);
+            // Show agent reload config
+            if (res.agent_reload) {
+                const r = res.agent_reload;
+                console.log();
+                if (r.enabled) {
+                    console.log(`  ${chalk.dim('Agent Reload:')}  ${chalk.green('ON')}`);
+                    console.log(`  ${chalk.dim('Amount:')}        $${r.amount_usd.toFixed(2)}`);
+                    console.log(`  ${chalk.dim('Daily Limit:')}   $${r.daily_limit_usd.toFixed(2)}`);
+                    console.log(`  ${chalk.dim('Chains:')}        ${r.chains.join(', ')}`);
+                }
+                else {
+                    console.log(`  ${chalk.dim('Agent Reload:')}  ${chalk.dim('OFF')}`);
+                }
+            }
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+    // ── llm reload ────────────────────────────────────────
+    llmCmd
+        .command('reload')
+        .description('Reload BFun.bot Credits from trading wallet')
+        .option('--disable', 'Emergency disable agent reload')
+        .action(async (opts, cmd) => {
+        try {
+            if (opts.disable) {
+                await agent.disableReload();
+                const isJson = cmd.optsWithGlobals().json;
+                if (isJson) {
+                    console.log(JSON.stringify({ disabled: true }));
+                }
+                else {
+                    success('Agent reload disabled. Re-enable from your BFunBot dashboard.');
+                }
+                return;
+            }
+            const isJson = cmd.optsWithGlobals().json;
+            const spinner = ora('Reloading BFun.bot Credits from trading wallet...').start();
+            const res = await agent.reloadCredits();
+            if (isJson) {
+                spinner.stop();
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            spinner.succeed('Reload complete!');
+            printCard('BFun.bot Credit Reload', [
+                ['Amount', `$${res.amount_usd}`],
+                ['Tx Hash', res.tx_hash],
+                ['New Balance', res.new_balance_usd ? `$${res.new_balance_usd}` : undefined],
+                ['Daily Used', `$${res.daily_used_usd} / $${res.daily_remaining_usd} remaining`],
+            ]);
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+    // ── llm setup ─────────────────────────────────────────
+    llmCmd
+        .command('setup <target>')
+        .description('Generate config for OpenClaw')
+        .option('--install', 'Write config directly to ~/.openclaw/openclaw.json')
+        .action(async (target, opts, cmd) => {
+        const config = readConfig();
+        const apiKey = config.apiKey || process.env['BFUN_API_KEY'];
+        if (!apiKey) {
+            console.error("Error: Not logged in. Run 'bfunbot login' first.");
+            process.exit(1);
+        }
+        switch (target.toLowerCase()) {
+            case 'openclaw': {
+                // Fetch model catalog from API — always up-to-date
+                let apiConfig;
+                try {
+                    apiConfig = await llm.openclawConfig();
+                }
+                catch (err) {
+                    console.error('Error: Could not fetch model catalog from BFunBot API.');
+                    if (err instanceof Error)
+                        console.error(`  ${err.message}`);
+                    process.exit(1);
+                }
+                // Build allowlist from fetched models
+                const allowlist = {};
+                for (const m of apiConfig.models) {
+                    allowlist[`bfunbot/${m.id}`] = { alias: m.id };
+                }
+                const openclawConfig = {
+                    models: {
+                        mode: 'merge',
+                        providers: {
+                            bfunbot: {
+                                baseUrl: apiConfig.baseUrl,
+                                apiKey: apiKey,
+                                api: apiConfig.api,
+                                models: apiConfig.models.map(({ input, ...rest }) => rest),
+                            },
+                        },
+                    },
+                    agents: {
+                        defaults: {
+                            models: allowlist,
+                        },
+                    },
+                };
+                if (opts.install) {
+                    try {
+                        const { readFileSync, writeFileSync, existsSync, mkdirSync } = await import('node:fs');
+                        const { join } = await import('node:path');
+                        const { homedir } = await import('node:os');
+                        const configDir = join(homedir(), '.openclaw');
+                        const configPath = join(configDir, 'openclaw.json');
+                        let existing = {};
+                        if (existsSync(configPath)) {
+                            try {
+                                existing = JSON.parse(readFileSync(configPath, 'utf-8'));
+                            }
+                            catch {
+                                existing = {};
+                            }
+                        }
+                        else {
+                            mkdirSync(configDir, { recursive: true });
+                        }
+                        // Deep merge providers
+                        existing.models = existing.models || {};
+                        existing.models.mode = 'merge';
+                        existing.models.providers = existing.models.providers || {};
+                        existing.models.providers.bfunbot = openclawConfig.models.providers.bfunbot;
+                        // Deep merge agents.defaults.models (allowlist + aliases)
+                        existing.agents = existing.agents || {};
+                        existing.agents.defaults = existing.agents.defaults || {};
+                        existing.agents.defaults.models = existing.agents.defaults.models || {};
+                        Object.assign(existing.agents.defaults.models, openclawConfig.agents.defaults.models);
+                        writeFileSync(configPath, JSON.stringify(existing, null, 2) + '\n', 'utf-8');
+                        success(`BFunBot provider added to ${configPath}`);
+                        console.log(chalk.dim('  Restart OpenClaw: openclaw gateway restart'));
+                    }
+                    catch (err) {
+                        console.error(`Error: Failed to write config — ${err instanceof Error ? err.message : err}`);
+                        process.exit(1);
+                    }
+                }
+                else {
+                    console.log();
+                    console.log(chalk.bold.cyan('OpenClaw Configuration'));
+                    console.log(chalk.dim('─'.repeat(40)));
+                    console.log();
+                    console.log('Add this to your ~/.openclaw/openclaw.json:');
+                    console.log();
+                    console.log(JSON.stringify(openclawConfig, null, 2));
+                    console.log();
+                    console.log(chalk.dim('Or run: bfunbot llm setup openclaw --install'));
+                    console.log();
+                }
+                break;
+            }
+            default:
+                console.error(`Error: Unknown target '${target}'. Supported: openclaw`);
+                process.exit(1);
+        }
+    });
+}

package/dist/commands/login.d.ts

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