@bfun-bot/cli 1.0.7 → 1.0.8

package/README.md

@@ -17,7 +17,7 @@ bfunbot login
 # Create a token
 bfunbot token create --name "My Token" --symbol MYT
 
-# Check balances
+# Check balances (with live USD values)
 bfunbot balances
 
 # Check fee earnings
@@ -35,15 +35,15 @@ bfunbot fees
 | `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 balances` | Show wallet balances (BSC) with live USD values |
+| `bfunbot quota` | Show daily token creation quota |
+| `bfunbot fees` | Check total fee earnings summary (with live USD) |
+| `bfunbot fees breakdown` | Per-platform fee breakdown (flap + fourmeme) |
+| `bfunbot fees --platform <p> --token <addr>` | Per-token fee detail |
 | `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 |

package/dist/__tests__/commands/balances.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/commands/balances.test.js

@@ -0,0 +1,97 @@
+/**
+ * Tests for bfunbot balances command.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Command } from 'commander';
+vi.mock('../../lib/api.js', () => ({
+    agent: {
+        walletBalance: vi.fn(),
+    },
+    handleApiError: vi.fn((err) => { throw err; }),
+}));
+import { agent } from '../../lib/api.js';
+import { registerBalances } from '../../commands/balances.js';
+const MOCK_BALANCE = {
+    evm_main: {
+        address: '0xB305ce8D75498E4D0c2963089C4894b3589F7777',
+        balance_bnb: '0.412',
+        balance_usdt_bsc: '100.5',
+        bnb_error: null,
+        usdt_bsc_error: null,
+    },
+    evm_trading: {
+        address: '0xDeaD000000000000000042069420694206942069',
+        balance_bnb: '0.050',
+        balance_usdt_bsc: '0',
+        bnb_error: null,
+        usdt_bsc_error: null,
+    },
+    bnb_price_usd: 600,
+};
+function buildProgram() {
+    const program = new Command();
+    program.option('--json');
+    registerBalances(program);
+    return program;
+}
+describe('bfunbot balances', () => {
+    let output;
+    beforeEach(() => {
+        output = [];
+        vi.spyOn(console, 'log').mockImplementation((...args) => {
+            output.push(args.map(String).join(' '));
+        });
+        vi.mocked(agent.walletBalance).mockResolvedValue(MOCK_BALANCE);
+    });
+    afterEach(() => vi.restoreAllMocks());
+    it('shows EVM Main wallet label', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'balances']);
+        expect(output.join('\n')).toContain('EVM Main');
+    });
+    it('shows EVM Trading wallet label', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'balances']);
+        expect(output.join('\n')).toContain('EVM Trading');
+    });
+    it('shows BNB balance', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'balances']);
+        expect(output.join('\n')).toContain('0.412');
+    });
+    it('shows USD equivalent alongside BNB', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'balances']);
+        expect(output.join('\n')).toContain('$');
+    });
+    it('shows USDT balance when non-zero', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'balances']);
+        expect(output.join('\n')).toContain('100.5');
+    });
+    it('shows error indicator when bnb_error is set', async () => {
+        vi.mocked(agent.walletBalance).mockResolvedValue({
+            ...MOCK_BALANCE,
+            evm_main: { ...MOCK_BALANCE.evm_main, bnb_error: 'rpc_unavailable' },
+        });
+        const stderrOutput = [];
+        vi.spyOn(console, 'error').mockImplementation((...args) => stderrOutput.push(args.map(String).join(' ')));
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'balances']);
+        expect(output.join('\n')).toContain('error');
+    });
+    it('shows truncated address', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'balances']);
+        expect(output.join('\n')).toContain('...');
+    });
+    it('outputs JSON when --json flag is passed', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', '--json', 'balances']);
+        const jsonLine = output.find(l => l.trim().startsWith('{'));
+        expect(jsonLine).toBeDefined();
+        const parsed = JSON.parse(jsonLine);
+        expect(parsed.evm_main.balance_bnb).toBe('0.412');
+        expect(parsed.bnb_price_usd).toBe(600);
+    });
+});

package/dist/__tests__/commands/fees.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/commands/fees.test.js

@@ -0,0 +1,220 @@
+/**
+ * Tests for bfunbot fees command.
+ *
+ * Mocks the agent API and asserts stdout output contains expected values.
+ * Does NOT assert exact formatting strings — those are covered in display.test.ts.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Command } from 'commander';
+// Mock the API module before importing the command
+vi.mock('../../lib/api.js', () => ({
+    agent: {
+        feesSummary: vi.fn(),
+        feesEarnings: vi.fn(),
+        feesToken: vi.fn(),
+    },
+    handleApiError: vi.fn((err) => { throw err; }),
+}));
+import { agent } from '../../lib/api.js';
+import { registerFees } from '../../commands/fees.js';
+const MOCK_SUMMARY = {
+    bsc: { token_count: 3, total_earned_bnb: 0.00412 },
+    bnb_price_usd: 600,
+};
+const MOCK_EARNINGS = {
+    chain: 'bsc',
+    flap: { total_earned_bnb: 0.00300, earning_token_count: 2 },
+    fourmeme: { total_earned_bnb: 0.00112, earning_token_count: 1 },
+};
+const MOCK_TOKEN_BSC = {
+    token_address: '0xB305ce8D75498E4D0c2963089C4894b3589F7777',
+    token_name: 'TestToken',
+    token_symbol: 'TEST',
+    platform: 'flap',
+    chain: 'bsc',
+    earned_bnb: 0.00300,
+};
+function buildProgram() {
+    const program = new Command();
+    program.option('--json');
+    registerFees(program);
+    return program;
+}
+describe('bfunbot fees (summary)', () => {
+    let output;
+    beforeEach(() => {
+        output = [];
+        vi.spyOn(console, 'log').mockImplementation((...args) => {
+            output.push(args.map(String).join(' '));
+        });
+        vi.mocked(agent.feesSummary).mockResolvedValue(MOCK_SUMMARY);
+    });
+    afterEach(() => vi.restoreAllMocks());
+    it('shows total earned BNB', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'fees']);
+        const all = output.join('\n');
+        expect(all).toContain('BNB');
+        expect(all).toContain('0.00412');
+    });
+    it('shows USD value when bnb_price_usd is provided', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'fees']);
+        const all = output.join('\n');
+        expect(all).toContain('$');
+    });
+    it('shows hint to run fees breakdown', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'fees']);
+        expect(output.join('\n')).toContain('breakdown');
+    });
+    it('outputs JSON when --json flag is passed', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', '--json', 'fees']);
+        const jsonLine = output.find(l => l.trim().startsWith('{'));
+        expect(jsonLine).toBeDefined();
+        const parsed = JSON.parse(jsonLine);
+        expect(parsed.bsc.total_earned_bnb).toBe(0.00412);
+    });
+});
+describe('bfunbot fees breakdown', () => {
+    let output;
+    beforeEach(() => {
+        output = [];
+        vi.spyOn(console, 'log').mockImplementation((...args) => {
+            output.push(args.map(String).join(' '));
+        });
+        vi.mocked(agent.feesEarnings).mockResolvedValue(MOCK_EARNINGS);
+        vi.mocked(agent.feesSummary).mockResolvedValue(MOCK_SUMMARY);
+    });
+    afterEach(() => vi.restoreAllMocks());
+    it('still works when feesSummary fails (graceful fallback — no USD)', async () => {
+        vi.mocked(agent.feesSummary).mockRejectedValue(new Error('summary unavailable'));
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'fees', 'breakdown']);
+        const all = output.join('\n');
+        expect(all).toContain('flap');
+        expect(all).toContain('fourmeme');
+    });
+    it('does not call feesSummary when --json flag is used', async () => {
+        vi.mocked(agent.feesSummary).mockClear();
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', '--json', 'fees', 'breakdown']);
+        expect(agent.feesSummary).not.toHaveBeenCalled();
+    });
+    it('shows flap and fourmeme platforms', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'fees', 'breakdown']);
+        const all = output.join('\n');
+        expect(all).toContain('flap');
+        expect(all).toContain('fourmeme');
+    });
+    it('shows BNB earned for both platforms', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'fees', 'breakdown']);
+        const all = output.join('\n');
+        expect(all).toContain('0.003');
+        expect(all).toContain('0.00112');
+    });
+    it('shows USD column', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'fees', 'breakdown']);
+        expect(output.join('\n')).toContain('$');
+    });
+    it('shows token counts', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'fees', 'breakdown']);
+        const all = output.join('\n');
+        expect(all).toContain('2');
+        expect(all).toContain('1');
+    });
+});
+describe('bfunbot fees --token --platform', () => {
+    let output;
+    beforeEach(() => {
+        output = [];
+        vi.spyOn(console, 'log').mockImplementation((...args) => {
+            output.push(args.map(String).join(' '));
+        });
+        vi.mocked(agent.feesToken).mockResolvedValue(MOCK_TOKEN_BSC);
+        vi.mocked(agent.feesSummary).mockResolvedValue(MOCK_SUMMARY);
+    });
+    afterEach(() => vi.restoreAllMocks());
+    it('shows token name and symbol', async () => {
+        const program = buildProgram();
+        await program.parseAsync([
+            'node', 'bfunbot', 'fees',
+            '--platform', 'flap',
+            '--token', '0xB305ce8D75498E4D0c2963089C4894b3589F7777',
+        ]);
+        const all = output.join('\n');
+        expect(all).toContain('TestToken');
+        expect(all).toContain('TEST');
+    });
+    it('shows earned BNB with USD', async () => {
+        const program = buildProgram();
+        await program.parseAsync([
+            'node', 'bfunbot', 'fees',
+            '--platform', 'flap',
+            '--token', '0xB305ce8D75498E4D0c2963089C4894b3589F7777',
+        ]);
+        const all = output.join('\n');
+        expect(all).toContain('BNB');
+        expect(all).toContain('$');
+    });
+    it('errors if --token given without --platform', async () => {
+        const stderrOutput = [];
+        vi.spyOn(console, 'error').mockImplementation((...args) => {
+            stderrOutput.push(args.map(String).join(' '));
+        });
+        vi.spyOn(process, 'exit').mockImplementation((() => {
+            throw new Error('process.exit(1)');
+        }));
+        const program = buildProgram();
+        await expect(program.parseAsync(['node', 'bfunbot', 'fees', '--token', '0xabc123'])).rejects.toThrow('process.exit(1)');
+        expect(stderrOutput[0]).toContain('--platform');
+    });
+    it('still works when feesSummary fails for per-token (graceful fallback)', async () => {
+        vi.mocked(agent.feesSummary).mockRejectedValue(new Error('summary unavailable'));
+        const program = buildProgram();
+        await program.parseAsync([
+            'node', 'bfunbot', 'fees',
+            '--platform', 'flap',
+            '--token', '0xB305ce8D75498E4D0c2963089C4894b3589F7777',
+        ]);
+        const all = output.join('\n');
+        expect(all).toContain('TestToken');
+        expect(all).toContain('BNB');
+    });
+    it('does not call feesSummary for --token when --json flag is used', async () => {
+        vi.mocked(agent.feesSummary).mockClear();
+        const program = buildProgram();
+        await program.parseAsync([
+            'node', 'bfunbot', '--json', 'fees',
+            '--platform', 'flap',
+            '--token', '0xB305ce8D75498E4D0c2963089C4894b3589F7777',
+        ]);
+        expect(agent.feesSummary).not.toHaveBeenCalled();
+    });
+    it('routes --platform alone to breakdown with deprecation hint', async () => {
+        vi.mocked(agent.feesEarnings).mockResolvedValue(MOCK_EARNINGS);
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'fees', '--platform', 'flap']);
+        const all = output.join('\n');
+        expect(all).toContain('flap');
+        expect(all).toContain('fourmeme');
+        expect(all).toContain('fees breakdown');
+    });
+    it('errors if invalid platform given', async () => {
+        const stderrOutput = [];
+        vi.spyOn(console, 'error').mockImplementation((...args) => {
+            stderrOutput.push(args.map(String).join(' '));
+        });
+        vi.spyOn(process, 'exit').mockImplementation((() => {
+            throw new Error('process.exit(1)');
+        }));
+        const program = buildProgram();
+        await expect(program.parseAsync(['node', 'bfunbot', 'fees', '--platform', 'invalid', '--token', '0xabc'])).rejects.toThrow('process.exit(1)');
+        expect(stderrOutput[0]).toContain('Platform must be one of');
+    });
+});

package/dist/__tests__/commands/quota.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/commands/quota.test.js

@@ -0,0 +1,104 @@
+/**
+ * Tests for bfunbot quota command.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Command } from 'commander';
+vi.mock('../../lib/api.js', () => ({
+    agent: {
+        quota: vi.fn(),
+    },
+    handleApiError: vi.fn((err) => { throw err; }),
+}));
+import { agent } from '../../lib/api.js';
+import { registerQuota } from '../../commands/quota.js';
+const MOCK_QUOTA = {
+    chains: [
+        {
+            chain: 'bsc',
+            free_used_today: 2,
+            free_limit: 5,
+            sponsored_remaining: 3,
+            can_create_paid: true,
+            trading_wallet_balance: '0.050000 BNB',
+            trading_wallet_address: '0xDeaD000000000000000042069420694206942069',
+        },
+    ],
+};
+function buildProgram() {
+    const program = new Command();
+    program.option('--json');
+    registerQuota(program);
+    return program;
+}
+describe('bfunbot quota', () => {
+    let output;
+    beforeEach(() => {
+        output = [];
+        vi.spyOn(console, 'log').mockImplementation((...args) => {
+            output.push(args.map(String).join(' '));
+        });
+        vi.mocked(agent.quota).mockResolvedValue(MOCK_QUOTA);
+    });
+    afterEach(() => vi.restoreAllMocks());
+    it('shows chain name', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'quota']);
+        expect(output.join('\n')).toContain('Bsc');
+    });
+    it('shows free used and limit', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'quota']);
+        const all = output.join('\n');
+        expect(all).toContain('2');
+        expect(all).toContain('5');
+    });
+    it('shows remaining quota count', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'quota']);
+        expect(output.join('\n')).toContain('3');
+    });
+    it('shows Yes for can_create_paid=true', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'quota']);
+        expect(output.join('\n')).toContain('Yes');
+    });
+    it('shows No only when both free remaining and can_create_paid are false/zero', async () => {
+        vi.mocked(agent.quota).mockResolvedValue({
+            chains: [{ ...MOCK_QUOTA.chains[0], can_create_paid: false, sponsored_remaining: 0 }],
+        });
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'quota']);
+        expect(output.join('\n')).toContain('No');
+    });
+    it('shows Yes when free remaining > 0 even if can_create_paid is false', async () => {
+        vi.mocked(agent.quota).mockResolvedValue({
+            chains: [{ ...MOCK_QUOTA.chains[0], can_create_paid: false, sponsored_remaining: 9 }],
+        });
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'quota']);
+        expect(output.join('\n')).toContain('Yes');
+    });
+    it('table columns align (ANSI-aware)', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', 'quota']);
+        const strip = (s) => s.replace(/\x1B\[[0-9;]*m/g, '');
+        // Find the header row (contains all column names)
+        const headerIdx = output.findIndex(l => strip(l).includes('Chain') && strip(l).includes('Used Today'));
+        expect(headerIdx).toBeGreaterThan(-1);
+        const headerLen = strip(output[headerIdx]).length;
+        // Data rows immediately follow the separator line — check they match header width
+        const separatorIdx = output.findIndex((l, i) => i > headerIdx && strip(l).includes('─'));
+        const dataRows = output.slice(separatorIdx + 1).filter(l => l.trim() !== '');
+        for (const row of dataRows) {
+            expect(strip(row).length).toBe(headerLen);
+        }
+    });
+    it('outputs JSON when --json flag is passed', async () => {
+        const program = buildProgram();
+        await program.parseAsync(['node', 'bfunbot', '--json', 'quota']);
+        const jsonLine = output.find(l => l.trim().startsWith('{'));
+        expect(jsonLine).toBeDefined();
+        const parsed = JSON.parse(jsonLine);
+        expect(parsed.chains[0].chain).toBe('bsc');
+    });
+});

package/dist/__tests__/lib/api.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/lib/api.test.js

@@ -0,0 +1,77 @@
+/**
+ * Tests for src/lib/api.ts
+ *
+ * Covers: ApiError construction, handleApiError friendly messages,
+ * request() — correct headers, error mapping, network failure.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ApiError, handleApiError } from '../../lib/api.js';
+// ─── ApiError ────────────────────────────────────────────────────────────────
+describe('ApiError', () => {
+    it('constructs with status code and message', () => {
+        const err = new ApiError(404, 'Not Found', { detail: 'Token not found' });
+        expect(err.statusCode).toBe(404);
+        expect(err.message).toBe('Token not found');
+        expect(err.name).toBe('ApiError');
+    });
+    it('falls back to statusText when no body detail', () => {
+        const err = new ApiError(500, 'Internal Server Error');
+        expect(err.message).toBe('Internal Server Error');
+    });
+    it('uses body.message if detail is absent', () => {
+        const err = new ApiError(400, 'Bad Request', { message: 'Bad input' });
+        expect(err.message).toBe('Bad input');
+    });
+});
+// ─── handleApiError friendly messages ────────────────────────────────────────
+describe('handleApiError', () => {
+    let stderrOutput;
+    beforeEach(() => {
+        stderrOutput = [];
+        vi.spyOn(console, 'error').mockImplementation((...args) => {
+            stderrOutput.push(args.map(String).join(' '));
+        });
+        vi.spyOn(process, 'exit').mockImplementation((() => { }));
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('shows login hint for 401', () => {
+        handleApiError(new ApiError(401, 'Unauthorized'));
+        expect(stderrOutput[0]).toContain('bfunbot login');
+    });
+    it('shows access denied for 403', () => {
+        handleApiError(new ApiError(403, 'Forbidden'));
+        expect(stderrOutput[0]).toContain('Access denied');
+    });
+    it('shows 403 detail string if provided', () => {
+        handleApiError(new ApiError(403, 'Forbidden', { detail: 'IP not allowed' }));
+        expect(stderrOutput[0]).toContain('IP not allowed');
+    });
+    it('shows rate limit message for 429', () => {
+        handleApiError(new ApiError(429, 'Too Many Requests'));
+        expect(stderrOutput[0]).toContain('Rate limited');
+    });
+    it('shows server error for 500+', () => {
+        handleApiError(new ApiError(503, 'Service Unavailable'));
+        expect(stderrOutput[0]).toContain('Server error');
+    });
+    it('joins FastAPI 422 validation errors', () => {
+        handleApiError(new ApiError(422, 'Unprocessable Entity', {
+            detail: [
+                { msg: 'field required', loc: ['body', 'name'], type: 'missing' },
+                { msg: 'invalid value', loc: ['body', 'symbol'], type: 'value_error' },
+            ],
+        }));
+        expect(stderrOutput[0]).toContain('field required');
+        expect(stderrOutput[0]).toContain('invalid value');
+    });
+    it('shows connection error for network TypeError', () => {
+        handleApiError(new TypeError('fetch failed', { cause: new Error('ECONNREFUSED') }));
+        expect(stderrOutput[0]).toContain('Could not reach');
+    });
+    it('calls process.exit(1)', () => {
+        handleApiError(new ApiError(401, 'Unauthorized'));
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+});

package/dist/__tests__/lib/display.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/lib/display.test.js

@@ -0,0 +1,210 @@
+/**
+ * Tests for src/lib/display.ts
+ *
+ * Covers: fmtBalance, fmtBnbWithUsd, fmtUsd, shortAddr, fmtDate, printTable alignment.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { fmtBalance, fmtBnbWithUsd, fmtUsd, shortAddr, fmtDate, printTable, } from '../../lib/display.js';
+// Strip ANSI codes from output for readable assertions
+const strip = (s) => s.replace(/\x1B\[[0-9;]*m/g, '');
+// ─── fmtBalance ──────────────────────────────────────────────────────────────
+describe('fmtBalance', () => {
+    it('formats a normal BNB value', () => {
+        expect(strip(fmtBalance('1.5', 'BNB'))).toBe('1.5 BNB');
+    });
+    it('trims trailing zeros', () => {
+        expect(strip(fmtBalance('1.500000', 'BNB'))).toBe('1.5 BNB');
+    });
+    it('formats a small value without scientific notation', () => {
+        const result = strip(fmtBalance('0.00000597', 'BNB'));
+        expect(result).not.toContain('e');
+        expect(result).toContain('0.00000597');
+        expect(result).toContain('BNB');
+    });
+    it('formats an extremely small value without scientific notation', () => {
+        const result = strip(fmtBalance('0.0000000012', 'BNB'));
+        expect(result).not.toContain('e');
+        expect(result).toContain('BNB');
+    });
+    it('returns dim zero for zero value', () => {
+        expect(strip(fmtBalance('0', 'BNB'))).toBe('0 BNB');
+    });
+    it('returns dim zero for null', () => {
+        expect(strip(fmtBalance(null, 'BNB'))).toBe('0 BNB');
+    });
+    it('returns dim zero for undefined', () => {
+        expect(strip(fmtBalance(undefined, 'BNB'))).toBe('0 BNB');
+    });
+    it('returns dim zero for "0.0"', () => {
+        expect(strip(fmtBalance('0.0', 'BNB'))).toBe('0 BNB');
+    });
+    it('formats USDT correctly', () => {
+        expect(strip(fmtBalance('100.5', 'USDT'))).toBe('100.5 USDT');
+    });
+    it('handles 6 decimal places without trailing zeros', () => {
+        expect(strip(fmtBalance('0.412000', 'BNB'))).toBe('0.412 BNB');
+    });
+    it('never shows 0 for a non-zero sub-1e-10 value', () => {
+        const result = strip(fmtBalance('0.00000000001', 'BNB'));
+        expect(result).not.toMatch(/^0 BNB/);
+        expect(result).not.toContain('e');
+        expect(result).toContain('BNB');
+    });
+});
+// ─── fmtBnbWithUsd ───────────────────────────────────────────────────────────
+describe('fmtBnbWithUsd', () => {
+    it('appends USD value in parentheses', () => {
+        const result = strip(fmtBnbWithUsd('1.0', 600));
+        expect(result).toContain('1 BNB');
+        expect(result).toContain('~$600.00');
+    });
+    it('calculates USD correctly for fractional BNB', () => {
+        const result = strip(fmtBnbWithUsd('0.5', 600));
+        expect(result).toContain('~$300.00');
+    });
+    it('returns plain BNB when price is 0', () => {
+        const result = strip(fmtBnbWithUsd('1.0', 0));
+        expect(result).toContain('BNB');
+        expect(result).not.toContain('$');
+    });
+    it('returns plain BNB for null value', () => {
+        const result = strip(fmtBnbWithUsd(null, 600));
+        expect(result).not.toContain('$');
+    });
+    it('returns plain BNB for zero value', () => {
+        const result = strip(fmtBnbWithUsd('0', 600));
+        expect(result).not.toContain('$');
+    });
+    it('handles very small BNB with USD', () => {
+        const result = strip(fmtBnbWithUsd('0.00001', 600));
+        expect(result).not.toContain('e');
+        expect(result).toContain('BNB');
+        expect(result).toContain('~$');
+    });
+});
+// ─── fmtUsd ──────────────────────────────────────────────────────────────────
+describe('fmtUsd', () => {
+    it('formats values >= $1 to 2 decimal places', () => {
+        expect(strip(fmtUsd('12.5'))).toBe('$12.50');
+    });
+    it('formats zero with em dash', () => {
+        expect(strip(fmtUsd('0'))).toBe('—');
+    });
+    it('formats null with em dash', () => {
+        expect(strip(fmtUsd(null))).toBe('—');
+    });
+    it('formats undefined with em dash', () => {
+        expect(strip(fmtUsd(undefined))).toBe('—');
+    });
+    it('formats small values with enough significant digits', () => {
+        const result = strip(fmtUsd('0.000123'));
+        expect(result).toContain('$');
+        expect(result).toContain('0.000123');
+    });
+    it('formats large USD values correctly', () => {
+        expect(strip(fmtUsd('1234.567'))).toBe('$1234.57');
+    });
+});
+// ─── shortAddr ───────────────────────────────────────────────────────────────
+describe('shortAddr', () => {
+    it('truncates a long address', () => {
+        const addr = '0xB305ce8D75498E4D0c2963089C4894b3589F7777';
+        const result = strip(shortAddr(addr));
+        expect(result).toContain('0xB305ce');
+        expect(result).toContain('...');
+        expect(result).toContain('F7777');
+        expect(result.length).toBeLessThan(addr.length);
+    });
+    it('returns em dash for null', () => {
+        expect(strip(shortAddr(null))).toBe('—');
+    });
+    it('returns em dash for undefined', () => {
+        expect(strip(shortAddr(undefined))).toBe('—');
+    });
+    it('returns short address as-is', () => {
+        expect(strip(shortAddr('0x1234'))).toBe('0x1234');
+    });
+});
+// ─── fmtDate ─────────────────────────────────────────────────────────────────
+describe('fmtDate', () => {
+    it('formats a valid ISO date string', () => {
+        const result = strip(fmtDate('2024-01-15T10:30:00Z'));
+        expect(result).toContain('2024');
+        expect(result).toContain('Jan');
+        expect(result).toContain('15');
+    });
+    it('returns em dash for null', () => {
+        expect(strip(fmtDate(null))).toBe('—');
+    });
+    it('returns em dash for undefined', () => {
+        expect(strip(fmtDate(undefined))).toBe('—');
+    });
+});
+// ─── printTable alignment ────────────────────────────────────────────────────
+describe('printTable', () => {
+    let output;
+    beforeEach(() => {
+        output = [];
+        vi.spyOn(console, 'log').mockImplementation((...args) => {
+            output.push(args.map(String).join(' '));
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('produces consistent column widths with plain text', () => {
+        printTable(['Name', 'Value', 'Status'], [
+            ['Alice', '100', 'active'],
+            ['Bob', '9999', 'inactive'],
+        ]);
+        const rows = output.filter(l => l.trim() && !l.includes('─'));
+        // All rows should have the same length (same column widths)
+        const header = strip(rows[0]);
+        const row1 = strip(rows[1]);
+        const row2 = strip(rows[2]);
+        expect(row1.length).toBe(header.length);
+        expect(row2.length).toBe(header.length);
+    });
+    it('correctly aligns columns when cells contain chalk colors (ANSI codes)', async () => {
+        const { default: chalk } = await import('chalk');
+        printTable(['Chain', 'Used Today', 'Can Create'], [
+            [chalk.bold('BSC'), '5', chalk.green('Yes')],
+            [chalk.bold('ETH'), '10', chalk.dim('No')],
+        ]);
+        const rows = output.filter(l => l.trim() && !l.includes('─'));
+        // Visible (stripped) lengths of all rows must be equal
+        const lengths = rows.map(r => strip(r).length);
+        expect(lengths.every(l => l === lengths[0])).toBe(true);
+    });
+    it('correctly handles CJK wide characters in column width calculation', async () => {
+        printTable(['Name', 'Symbol'], [
+            ['普通Token', 'ABC'], // CJK chars — each is 2 columns wide
+            ['NormalName', 'XYZ'],
+        ]);
+        // Find separator line to locate data rows
+        const sepIdx = output.findIndex(l => strip(l).includes('─'));
+        const dataRows = output.slice(sepIdx + 1).filter(l => l.trim() !== '');
+        // Both data rows must have the same visible terminal width
+        const visW = (s) => {
+            let w = 0;
+            for (const ch of strip(s).trimEnd()) {
+                const cp = ch.codePointAt(0) ?? 0;
+                w += (cp >= 0x4E00 && cp <= 0x9FFF) ? 2 : 1;
+            }
+            return w;
+        };
+        const lengths = dataRows.map(r => visW(r));
+        expect(lengths).toHaveLength(2);
+        expect(lengths[0]).toBe(lengths[1]);
+    });
+    it('handles empty rows gracefully', () => {
+        expect(() => printTable(['Col A', 'Col B'], [])).not.toThrow();
+    });
+    it('renders headers and separator', () => {
+        printTable(['Symbol', 'Name'], [['BTC', 'Bitcoin']]);
+        const allOutput = output.join('\n');
+        expect(allOutput).toContain('Symbol');
+        expect(allOutput).toContain('Name');
+        expect(allOutput).toContain('─');
+    });
+});

package/dist/commands/balances.js

@@ -1,24 +1,23 @@
 import chalk from 'chalk';
 import { agent, handleApiError } from '../lib/api.js';
-import { fmtBalance, shortAddr } from '../lib/display.js';
-function printWallet(label, slot) {
+import { fmtBalance, fmtBnbWithUsd, shortAddr } from '../lib/display.js';
+function printWallet(label, slot, bnbPriceUsd) {
     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)}`);
-        }
+    if (slot.bnb_error) {
+        console.log(`    ${'BNB (BSC)'.padEnd(14)} ${chalk.red('error')}`);
+    }
+    else {
+        console.log(`    ${'BNB (BSC)'.padEnd(14)} ${fmtBnbWithUsd(slot.balance_bnb, bnbPriceUsd)}`);
+    }
+    if (slot.usdt_bsc_error) {
+        console.log(`    ${'USDT (BSC)'.padEnd(14)} ${chalk.red('error')}`);
+    }
+    else if (slot.balance_usdt_bsc && parseFloat(slot.balance_usdt_bsc) > 0) {
+        console.log(`    ${'USDT (BSC)'.padEnd(14)} ${fmtBalance(slot.balance_usdt_bsc, 'USDT')}`);
     }
     console.log();
 }
@@ -38,8 +37,9 @@ export function registerBalances(program) {
             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);
+            const bnbPrice = res.bnb_price_usd ?? 0;
+            printWallet('EVM Main', res.evm_main, bnbPrice);
+            printWallet('EVM Trading', res.evm_trading, bnbPrice);
         }
         catch (err) {
             handleApiError(err);

package/dist/commands/fees.d.ts

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

package/dist/commands/fees.js

@@ -1,28 +1,40 @@
 import chalk from 'chalk';
 import { agent, handleApiError } from '../lib/api.js';
-import { fmtBalance, printTable } from '../lib/display.js';
+import { fmtBalance, fmtBnbWithUsd, printTable } from '../lib/display.js';
 const VALID_PLATFORMS = ['flap', 'fourmeme'];
 // ─── Display Helpers ─────────────────────────────────────
 function printSummary(res) {
+    const bnbPrice = res.bnb_price_usd ?? 0;
     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(`  ${chalk.bold('BSC (BNB Chain)')}`);
+    console.log(`    ${'Total Earned'.padEnd(22)} ${fmtBnbWithUsd(res.bsc.total_earned_bnb.toString(), bnbPrice)}`);
+    console.log();
+    console.log(chalk.dim(`  For per-platform breakdown: bfunbot fees breakdown`));
     console.log();
 }
-function printEarnings(res) {
+function printBreakdown(res, bnbPriceUsd) {
     console.log();
-    console.log(chalk.bold.cyan(`Fee Earnings · BSC`));
+    console.log(chalk.bold.cyan('Fee Earnings · Platform Breakdown'));
     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()],
+    printTable(['Platform', 'Earned', 'USD Value', 'Tokens'], [
+        [
+            'flap',
+            fmtBalance(res.flap.total_earned_bnb.toString(), 'BNB'),
+            bnbPriceUsd ? chalk.dim(`~$${(res.flap.total_earned_bnb * bnbPriceUsd).toFixed(2)}`) : chalk.dim('—'),
+            res.flap.earning_token_count.toString(),
+        ],
+        [
+            'fourmeme',
+            fmtBalance(res.fourmeme.total_earned_bnb.toString(), 'BNB'),
+            bnbPriceUsd ? chalk.dim(`~$${(res.fourmeme.total_earned_bnb * bnbPriceUsd).toFixed(2)}`) : chalk.dim('—'),
+            res.fourmeme.earning_token_count.toString(),
+        ],
     ]);
 }
-function printToken(res) {
+function printToken(res, bnbPriceUsd) {
     if ('supported' in res && res.supported === false) {
         console.log();
         console.log(chalk.yellow('⚠') + '  ' + res.message);
@@ -37,16 +49,16 @@ function printToken(res) {
     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(`  ${'Earned'.padEnd(14)} ${fmtBnbWithUsd(bsc.earned_bnb.toString(), bnbPriceUsd)}`);
     console.log();
 }
 // ─── Command Registration ─────────────────────────────────
 export function registerFees(program) {
-    program
+    const feesCmd = 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')
+        .description('Check fee earnings (summary, breakdown, or per-token)')
+        .option('--platform <platform>', 'Platform for per-token lookup: flap or fourmeme')
+        .option('--token <address>', 'Token contract address (requires --platform)')
         .action(async (opts, cmd) => {
         const isJson = cmd.optsWithGlobals().json;
         try {
@@ -61,27 +73,35 @@ export function registerFees(program) {
                     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);
+                const tokenRes = await agent.feesToken('bsc', platform, opts.token);
                 if (isJson) {
-                    console.log(JSON.stringify(res, null, 2));
+                    console.log(JSON.stringify(tokenRes, null, 2));
                     return;
                 }
-                printToken(res);
+                // Fetch price separately — graceful fallback if summary is unavailable
+                let bnbPrice = 0;
+                try {
+                    bnbPrice = (await agent.feesSummary()).bnb_price_usd ?? 0;
+                }
+                catch { /* non-fatal */ }
+                printToken(tokenRes, bnbPrice);
                 return;
             }
-            // Per-platform breakdown
+            // --platform alone (legacy): route to breakdown with deprecation hint
             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(chalk.dim('  Tip: use `bfunbot fees breakdown` for per-platform earnings'));
+                const earningsRes = await agent.feesEarnings('bsc');
                 if (isJson) {
-                    console.log(JSON.stringify(res, null, 2));
+                    console.log(JSON.stringify(earningsRes, null, 2));
                     return;
                 }
-                printEarnings(res);
+                let bnbPrice = 0;
+                try {
+                    bnbPrice = (await agent.feesSummary()).bnb_price_usd ?? 0;
+                }
+                catch { /* non-fatal */ }
+                printBreakdown(earningsRes, bnbPrice);
                 return;
             }
             // Default: summary
@@ -96,4 +116,28 @@ export function registerFees(program) {
             handleApiError(err);
         }
     });
+    // ── fees breakdown ────────────────────────────────────
+    feesCmd
+        .command('breakdown')
+        .description('Per-platform fee earnings (flap + fourmeme)')
+        .action(async (_, cmd) => {
+        const isJson = cmd.optsWithGlobals().json;
+        try {
+            const earningsRes = await agent.feesEarnings('bsc');
+            if (isJson) {
+                console.log(JSON.stringify(earningsRes, null, 2));
+                return;
+            }
+            // Price fetch is non-fatal — breakdown still works without USD values
+            let bnbPrice = 0;
+            try {
+                bnbPrice = (await agent.feesSummary()).bnb_price_usd ?? 0;
+            }
+            catch { /* non-fatal */ }
+            printBreakdown(earningsRes, bnbPrice);
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
 }

package/dist/commands/llm.js

@@ -49,12 +49,11 @@ export function registerLlm(program) {
                 return;
             }
             printCard('BFun.bot Credits', [
-                ['Balance', `$${res.balance_usd}`],
+                ['Balance', chalk.bold.white(`$${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)}`);

package/dist/commands/quota.js

@@ -13,13 +13,16 @@ export function registerQuota(program) {
                 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'),
-            ]));
+            printTable(['Chain', 'Used Today', 'Daily Limit', 'Remaining', 'Can Create'], res.chains.map((c) => {
+                const canCreate = c.sponsored_remaining > 0 || c.can_create_paid;
+                return [
+                    chalk.bold(c.chain.charAt(0).toUpperCase() + c.chain.slice(1)),
+                    `${c.free_used_today}`,
+                    `${c.free_limit}`,
+                    `${c.sponsored_remaining}`,
+                    canCreate ? chalk.green('Yes') : chalk.dim('No'),
+                ];
+            }));
         }
         catch (err) {
             handleApiError(err);

package/dist/commands/token.js

@@ -4,8 +4,8 @@ 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/',
+const TOKEN_VIEW_URLS = {
+    bsc: 'https://bfun.bot/tokens/',
 };
 export function registerToken(program) {
     const tokenCmd = program
@@ -97,7 +97,7 @@ export function registerToken(program) {
                     printCard('Token Deployed', [
                         ['Address', job.token_address],
                         ['Chain', 'BSC'],
-                        ['View', `${EXPLORER_URLS.bsc}${job.token_address}`],
+                        ['View', `${TOKEN_VIEW_URLS.bsc}${job.token_address}`],
                     ]);
                     return;
                 }
@@ -129,7 +129,7 @@ export function registerToken(program) {
                 console.log(JSON.stringify(res, null, 2));
                 return;
             }
-            const explorerBase = EXPLORER_URLS[res.chain] || '';
+            const viewBase = TOKEN_VIEW_URLS[res.chain] || '';
             printCard(`${res.symbol} — ${res.name}`, [
                 ['Address', res.token_address],
                 ['Chain', res.chain],
@@ -140,7 +140,7 @@ export function registerToken(program) {
                 ['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],
+                ['View', viewBase ? `${viewBase}${res.token_address}` : undefined],
             ]);
         }
         catch (err) {

package/dist/index.js

@@ -17,7 +17,6 @@ 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';
@@ -78,7 +77,6 @@ registerToken(program);
 registerStatus(program);
 registerBalances(program);
 registerQuota(program);
-registerSkills(program);
 registerLlm(program);
 registerConfig(program);
 registerAbout(program);

package/dist/lib/display.d.ts

@@ -4,6 +4,7 @@
 export declare function printCard(title: string, fields: [string, string | undefined][]): void;
 /**
  * Print a simple table with headers.
+ * Uses ANSI-stripped lengths for column width calculation so chalk colors don't break alignment.
  */
 export declare function printTable(headers: string[], rows: string[][]): void;
 /**
@@ -14,6 +15,11 @@ export declare function shortAddr(addr: string | undefined | null, chars?: numbe
  * Format a balance value.
  */
 export declare function fmtBalance(value: string | undefined | null, symbol: string): string;
+/**
+ * Format a BNB value with USD equivalent in parentheses.
+ * e.g. "0.00412 BNB (~$2.47)"
+ */
+export declare function fmtBnbWithUsd(value: string | undefined | null, bnbPriceUsd: number): string;
 /**
  * Format a USD value.
  */

package/dist/lib/display.js

@@ -2,6 +2,7 @@
  * Terminal display helpers — tables, cards, formatting.
  */
 import chalk from 'chalk';
+import stringWidth from 'string-width';
 /**
  * Print a key-value card.
  */
@@ -16,23 +17,38 @@ export function printCard(title, fields) {
     }
     console.log();
 }
+/**
+ * Get the visible terminal width of a string.
+ * Uses string-width which correctly handles ANSI codes, CJK wide chars,
+ * ZWJ emoji sequences, variation selectors, and all Unicode edge cases.
+ */
+function visibleWidth(str) {
+    return stringWidth(str);
+}
 /**
  * Print a simple table with headers.
+ * Uses ANSI-stripped lengths for column width calculation so chalk colors don't break alignment.
  */
 export function printTable(headers, rows) {
-    // Calculate column widths
+    // Calculate column widths using visible terminal width (handles ANSI + CJK wide chars)
     const widths = headers.map((h, i) => {
-        const maxRow = rows.reduce((max, row) => Math.max(max, (row[i] || '').length), 0);
-        return Math.max(h.length, maxRow);
+        const maxRow = rows.reduce((max, row) => Math.max(max, visibleWidth(row[i] || '')), 0);
+        return Math.max(visibleWidth(h), maxRow);
     });
     // Header
-    const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join('  ');
+    const headerLine = headers.map((h, i) => {
+        const padding = widths[i] - visibleWidth(h);
+        return h + ' '.repeat(Math.max(0, padding));
+    }).join('  ');
     console.log();
     console.log(chalk.bold(headerLine));
     console.log(chalk.dim(widths.map(w => '─'.repeat(w)).join('  ')));
-    // Rows
+    // Rows — pad by visible terminal width, not raw string length
     for (const row of rows) {
-        const line = row.map((cell, i) => (cell || '').padEnd(widths[i])).join('  ');
+        const line = row.map((cell, i) => {
+            const padding = widths[i] - visibleWidth(cell || '');
+            return (cell || '') + ' '.repeat(Math.max(0, padding));
+        }).join('  ');
         console.log(line);
     }
     console.log();
@@ -59,9 +75,45 @@ export function fmtBalance(value, symbol) {
         return chalk.dim(`0 ${symbol}`);
     if (num === 0)
         return chalk.dim(`0 ${symbol}`);
-    const formatted = num < 0.0001 ? num.toExponential(2) : num.toFixed(6).replace(/0+$/, '').replace(/\.$/, '');
+    // Use enough decimal places to always show significant digits for very small values.
+    // toFixed(10) rounds below 5e-11 to zero, so fall back to toPrecision for anything smaller.
+    let formatted;
+    if (num >= 0.0001) {
+        formatted = num.toFixed(6).replace(/0+$/, '').replace(/\.$/, '');
+    }
+    else if (num >= 5e-11) {
+        formatted = num.toFixed(10).replace(/0+$/, '').replace(/\.$/, '');
+    }
+    else {
+        // Extremely small: toPrecision gives enough sig figs, then convert from sci notation
+        formatted = parseFloat(num.toPrecision(4)).toFixed(20).replace(/0+$/, '').replace(/\.$/, '');
+    }
     return `${formatted} ${symbol}`;
 }
+/**
+ * Format a BNB value with USD equivalent in parentheses.
+ * e.g. "0.00412 BNB (~$2.47)"
+ */
+export function fmtBnbWithUsd(value, bnbPriceUsd) {
+    const bnbStr = fmtBalance(value, 'BNB');
+    if (!value || value === '0' || value === '0.0' || !bnbPriceUsd)
+        return bnbStr;
+    const num = parseFloat(value);
+    if (isNaN(num) || num === 0)
+        return bnbStr;
+    const usd = num * bnbPriceUsd;
+    return `${bnbStr} ${chalk.dim('(~' + fmtUsdInline(usd) + ')')}`;
+}
+function fmtUsdInline(usd) {
+    if (usd >= 1)
+        return `$${usd.toFixed(2)}`;
+    if (usd === 0)
+        return '$0';
+    const str = usd.toFixed(10);
+    const match = str.match(/^0\.(0*)/);
+    const leadingZeros = match ? match[1].length : 0;
+    return `$${usd.toFixed(leadingZeros + 4)}`;
+}
 /**
  * Format a USD value.
  */

package/dist/types.d.ts

@@ -85,6 +85,7 @@ export interface WalletSlot {
 export interface WalletBalanceResponse {
     evm_main: WalletSlot;
     evm_trading: WalletSlot;
+    bnb_price_usd?: number;
 }
 export interface CreditBalanceResponse {
     balance_usd: string;
@@ -144,6 +145,7 @@ export interface FeeSummaryBsc {
 }
 export interface FeeSummaryResponse {
     bsc: FeeSummaryBsc;
+    bnb_price_usd?: number;
 }
 export interface FeeEarningsBsc {
     chain: 'bsc';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bfun-bot/cli",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "BFunBot CLI — deploy tokens, check balances, and manage your AI agent from the terminal",
   "type": "module",
   "bin": {
@@ -16,6 +16,9 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "prepublishOnly": "npm run build"
   },
   "engines": {
@@ -35,10 +38,13 @@
   "dependencies": {
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
-    "ora": "^8.1.1"
+    "ora": "^8.1.1",
+    "string-width": "^8.2.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "typescript": "^5.5.4"
+    "@vitest/coverage-v8": "^4.1.2",
+    "typescript": "^5.5.4",
+    "vitest": "^4.1.2"
   }
 }