@bfun-bot/cli 1.0.5

package/dist/lib/api.js

@@ -0,0 +1,172 @@
+/**
+ * HTTP client for the BFunBot Agent API + LLM Gateway.
+ *
+ * Uses native fetch (Node 18+). Handles auth headers, error mapping,
+ * and --debug logging.
+ */
+import { readConfig, requireApiKey } from './config.js';
+let debugEnabled = false;
+export function enableDebug() {
+    debugEnabled = true;
+}
+// ─── Error Classes ───────────────────────────────────────
+export class ApiError extends Error {
+    statusCode;
+    statusText;
+    body;
+    constructor(statusCode, statusText, body) {
+        const detail = body?.detail || body?.message || statusText;
+        super(detail);
+        this.statusCode = statusCode;
+        this.statusText = statusText;
+        this.body = body;
+        this.name = 'ApiError';
+    }
+}
+// ─── Friendly error messages ─────────────────────────────
+function friendlyError(err) {
+    switch (err.statusCode) {
+        case 401:
+            return "Invalid or expired API key. Run 'bfunbot login' to re-authenticate.";
+        case 403:
+            return err.body?.detail || 'Access denied. Your API key may not have the required permissions.';
+        case 404:
+            return err.body?.detail || 'Not found.';
+        case 429: {
+            const detail = err.body?.detail;
+            if (typeof detail === 'object' && detail !== null && 'message' in detail)
+                return detail.message;
+            if (typeof detail === 'string')
+                return detail;
+            return 'Rate limited. Try again later.';
+        }
+        default: {
+            if (err.statusCode >= 500) {
+                return 'Server error. Try again later.';
+            }
+            const detail = err.body?.detail;
+            if (typeof detail === 'string')
+                return detail;
+            if (typeof detail === 'object' && detail !== null) {
+                const d = detail;
+                return d.message || d.error || JSON.stringify(detail);
+            }
+            return err.message || `HTTP ${err.statusCode}`;
+        }
+    }
+}
+/**
+ * Print a friendly error message to stderr and exit.
+ */
+export function handleApiError(err) {
+    if (err instanceof ApiError) {
+        console.error(`Error: ${friendlyError(err)}`);
+        if (debugEnabled) {
+            console.error(`  Status: ${err.statusCode} ${err.statusText}`);
+            if (err.body)
+                console.error(`  Body: ${JSON.stringify(err.body)}`);
+        }
+    }
+    else if (err instanceof TypeError && err.cause) {
+        console.error('Error: Could not reach BFunBot API. Check your connection.');
+        if (debugEnabled)
+            console.error(`  ${err.message}`);
+    }
+    else {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    process.exit(1);
+}
+async function request(path, opts = {}) {
+    const { method = 'GET', body, auth = true, baseLlm = false } = opts;
+    const config = readConfig();
+    const baseUrl = baseLlm
+        ? (config.llmUrl || 'https://llm.bfun.bot/v1')
+        : (config.apiUrl || 'https://api.bfun.bot');
+    const url = `${baseUrl}${path}`;
+    const headers = {
+        'Accept': 'application/json',
+    };
+    if (auth) {
+        const apiKey = requireApiKey();
+        headers['X-API-Key'] = apiKey;
+    }
+    if (body) {
+        headers['Content-Type'] = 'application/json';
+    }
+    if (debugEnabled) {
+        console.error(`[debug] ${method} ${url}`);
+        if (body)
+            console.error(`[debug] Body: ${JSON.stringify(body)}`);
+    }
+    const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (debugEnabled) {
+        console.error(`[debug] Response: ${response.status} ${response.statusText}`);
+    }
+    if (!response.ok) {
+        let errorBody;
+        try {
+            errorBody = await response.json();
+            if (debugEnabled)
+                console.error(`[debug] Error body: ${JSON.stringify(errorBody)}`);
+        }
+        catch {
+            // non-JSON error response
+        }
+        throw new ApiError(response.status, response.statusText, errorBody);
+    }
+    // Handle 204 No Content (empty body)
+    if (response.status === 204) {
+        return undefined;
+    }
+    const data = await response.json();
+    if (debugEnabled) {
+        console.error(`[debug] Response body: ${JSON.stringify(data).slice(0, 500)}`);
+    }
+    return data;
+}
+// ─── Public API Methods ──────────────────────────────────
+// Agent API (base: /agent/v1)
+export const agent = {
+    me: () => request('/agent/v1/me'),
+    tokensCreated: (page = 1, pageSize = 20) => request(`/agent/v1/tokens/created?page=${page}&page_size=${pageSize}`),
+    tokenCreate: (body) => request('/agent/v1/token/create', {
+        method: 'POST',
+        body,
+    }),
+    tokenInfo: (address, chain) => {
+        const params = chain ? `?chain=${chain}` : '';
+        return request(`/agent/v1/token/${address}${params}`);
+    },
+    jobStatus: (jobId) => request(`/agent/v1/jobs/${jobId}`),
+    walletBalance: () => request('/agent/v1/balance/wallet'),
+    creditBalance: () => request('/agent/v1/balance/credits'),
+    reloadCredits: () => request('/agent/v1/balance/credits/reload', {
+        method: 'POST',
+        body: {},
+    }),
+    disableReload: () => request('/agent/v1/balance/credits/reload/disable', {
+        method: 'POST',
+        body: {},
+    }),
+    quota: () => request('/agent/v1/quota'),
+    skills: () => request('/agent/v1/skills', { auth: false }),
+    feesSummary: () => request('/agent/v1/fees/summary'),
+    feesEarnings: (chain) => request(`/agent/v1/fees/earnings?chain=${chain}`),
+    feesToken: (chain, platform, tokenAddress) => request(`/agent/v1/fees/token?chain=${chain}&platform=${platform}&token_address=${encodeURIComponent(tokenAddress)}`),
+};
+// LLM Gateway (base: /llm/v1)
+export const llm = {
+    models: () => request('/models', {
+        baseLlm: true,
+        auth: false,
+    }),
+    openclawConfig: () => request('/models/openclaw', {
+        baseLlm: true,
+        auth: false,
+    }),
+};

package/dist/lib/config.d.ts

@@ -0,0 +1,31 @@
+import type { BfunConfig } from '../types.js';
+declare const CONFIG_DIR: string;
+declare const CONFIG_PATH: string;
+declare const DEFAULT_API_URL = "https://api.bfun.bot";
+declare const DEFAULT_LLM_URL = "https://llm.bfun.bot/v1";
+/**
+ * Read config from disk. Returns defaults for missing values.
+ */
+export declare function readConfig(): BfunConfig;
+/**
+ * Write config to disk. Merges with existing config.
+ * Creates ~/.bfunbot/ if needed. Sets file permissions to 0600.
+ */
+export declare function writeConfig(updates: Partial<BfunConfig>): void;
+/**
+ * Delete config file (logout).
+ */
+export declare function clearConfig(): void;
+/**
+ * Get a specific config value.
+ */
+export declare function getConfigValue(key: keyof BfunConfig): string | undefined;
+/**
+ * Set a specific config value.
+ */
+export declare function setConfigValue(key: keyof BfunConfig, value: string): void;
+/**
+ * Get the API key or throw a helpful error.
+ */
+export declare function requireApiKey(): string;
+export { CONFIG_PATH, CONFIG_DIR, DEFAULT_API_URL, DEFAULT_LLM_URL };

package/dist/lib/config.js

@@ -0,0 +1,86 @@
+/**
+ * Config file management — read/write ~/.bfunbot/config.json
+ */
+import { readFileSync, writeFileSync, mkdirSync, chmodSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const CONFIG_DIR = join(homedir(), '.bfunbot');
+const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+const DEFAULT_API_URL = 'https://api.bfun.bot';
+const DEFAULT_LLM_URL = 'https://llm.bfun.bot/v1';
+/**
+ * Read config from disk. Returns defaults for missing values.
+ */
+export function readConfig() {
+    try {
+        if (!existsSync(CONFIG_PATH)) {
+            return { apiUrl: DEFAULT_API_URL, llmUrl: DEFAULT_LLM_URL };
+        }
+        const raw = readFileSync(CONFIG_PATH, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return {
+            apiUrl: DEFAULT_API_URL,
+            llmUrl: DEFAULT_LLM_URL,
+            ...parsed,
+        };
+    }
+    catch {
+        return { apiUrl: DEFAULT_API_URL, llmUrl: DEFAULT_LLM_URL };
+    }
+}
+/**
+ * Write config to disk. Merges with existing config.
+ * Creates ~/.bfunbot/ if needed. Sets file permissions to 0600.
+ */
+export function writeConfig(updates) {
+    const current = readConfig();
+    const merged = { ...current, ...updates };
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
+    chmodSync(CONFIG_PATH, 0o600);
+}
+/**
+ * Delete config file (logout).
+ */
+export function clearConfig() {
+    try {
+        if (existsSync(CONFIG_PATH)) {
+            writeFileSync(CONFIG_PATH, '{}\n', 'utf-8');
+            chmodSync(CONFIG_PATH, 0o600);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+/**
+ * Get a specific config value.
+ */
+export function getConfigValue(key) {
+    const config = readConfig();
+    return config[key];
+}
+/**
+ * Set a specific config value.
+ */
+export function setConfigValue(key, value) {
+    writeConfig({ [key]: value });
+}
+/**
+ * Get the API key or throw a helpful error.
+ */
+export function requireApiKey() {
+    // Env var takes precedence
+    const envKey = process.env['BFUN_API_KEY'];
+    if (envKey)
+        return envKey;
+    const config = readConfig();
+    if (!config.apiKey) {
+        console.error('Error: Not logged in. Run `bfunbot login` first.');
+        process.exit(1);
+    }
+    return config.apiKey;
+}
+export { CONFIG_PATH, CONFIG_DIR, DEFAULT_API_URL, DEFAULT_LLM_URL };

package/dist/lib/display.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Print a key-value card.
+ */
+export declare function printCard(title: string, fields: [string, string | undefined][]): void;
+/**
+ * Print a simple table with headers.
+ */
+export declare function printTable(headers: string[], rows: string[][]): void;
+/**
+ * Truncate an address for display.
+ */
+export declare function shortAddr(addr: string | undefined | null, chars?: number): string;
+/**
+ * Format a balance value.
+ */
+export declare function fmtBalance(value: string | undefined | null, symbol: string): string;
+/**
+ * Format a USD value.
+ */
+export declare function fmtUsd(value: string | undefined | null): string;
+/**
+ * Format a date string.
+ */
+export declare function fmtDate(dateStr: string | undefined | null): string;
+/**
+ * Print a success message.
+ */
+export declare function success(msg: string): void;
+/**
+ * Print an error message to stderr.
+ */
+export declare function error(msg: string): void;
+/**
+ * Print a warning message.
+ */
+export declare function warn(msg: string): void;

package/dist/lib/display.js

@@ -0,0 +1,120 @@
+/**
+ * Terminal display helpers — tables, cards, formatting.
+ */
+import chalk from 'chalk';
+/**
+ * Print a key-value card.
+ */
+export function printCard(title, fields) {
+    console.log();
+    console.log(chalk.bold.cyan(title));
+    console.log(chalk.dim('─'.repeat(40)));
+    for (const [key, value] of fields) {
+        if (value !== undefined && value !== null && value !== '') {
+            console.log(`  ${chalk.dim(key + ':')}  ${value}`);
+        }
+    }
+    console.log();
+}
+/**
+ * Print a simple table with headers.
+ */
+export function printTable(headers, rows) {
+    // Calculate column widths
+    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);
+    });
+    // Header
+    const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join('  ');
+    console.log();
+    console.log(chalk.bold(headerLine));
+    console.log(chalk.dim(widths.map(w => '─'.repeat(w)).join('  ')));
+    // Rows
+    for (const row of rows) {
+        const line = row.map((cell, i) => (cell || '').padEnd(widths[i])).join('  ');
+        console.log(line);
+    }
+    console.log();
+}
+/**
+ * Truncate an address for display.
+ */
+export function shortAddr(addr, chars = 6) {
+    if (!addr)
+        return chalk.dim('—');
+    if (addr.length <= chars * 2 + 2)
+        return addr;
+    return `${addr.slice(0, chars + 2)}...${addr.slice(-chars)}`;
+}
+/**
+ * Format a balance value.
+ */
+export function fmtBalance(value, symbol) {
+    if (!value || value === '0' || value === '0.0')
+        return chalk.dim(`0 ${symbol}`);
+    // Trim trailing zeros after decimal
+    const num = parseFloat(value);
+    if (isNaN(num))
+        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(/\.$/, '');
+    return `${formatted} ${symbol}`;
+}
+/**
+ * Format a USD value.
+ */
+export function fmtUsd(value) {
+    if (!value)
+        return chalk.dim('—');
+    const num = parseFloat(value);
+    if (isNaN(num) || num === 0)
+        return chalk.dim('—');
+    if (num >= 1)
+        return `$${num.toFixed(2)}`;
+    // For small numbers, show enough significant digits
+    const str = num.toFixed(10);
+    const match = str.match(/^0\.(0*)/);
+    const leadingZeros = match ? match[1].length : 0;
+    const sigFigs = Math.max(leadingZeros + 4, 2);
+    return `$${num.toFixed(sigFigs)}`;
+}
+/**
+ * Format a date string.
+ */
+export function fmtDate(dateStr) {
+    if (!dateStr)
+        return chalk.dim('—');
+    try {
+        const d = new Date(dateStr);
+        return d.toLocaleDateString('en-US', {
+            year: 'numeric',
+            month: 'short',
+            day: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+        });
+    }
+    catch {
+        return dateStr;
+    }
+}
+/**
+ * Print a success message.
+ */
+export function success(msg) {
+    console.log(chalk.green('✓') + ' ' + msg);
+}
+/**
+ * Print an error message to stderr.
+ */
+export function error(msg) {
+    console.error(chalk.red('Error:') + ' ' + msg);
+}
+/**
+ * Print a warning message.
+ */
+export function warn(msg) {
+    console.log(chalk.yellow('⚠') + ' ' + msg);
+}

package/dist/types.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Shared TypeScript types for the BFunBot CLI.
+ */
+export interface BfunConfig {
+    apiKey?: string;
+    apiUrl?: string;
+    llmUrl?: string;
+    [key: string]: string | undefined;
+}
+export interface ApiErrorResponse {
+    detail?: string | Record<string, unknown>;
+    message?: string;
+}
+export interface MeResponse {
+    twitter_user_id: string;
+    twitter_username?: string;
+    profile_image_url?: string;
+    followers_count?: number;
+    joined_at?: string;
+    tos_accepted_at?: string;
+}
+export interface TokenCreateRequest {
+    name: string;
+    symbol: string;
+    description?: string;
+    image_url?: string;
+    source_url?: string;
+    chain: string;
+    platform: string;
+    twitter?: string;
+    telegram?: string;
+    website?: string;
+}
+export interface TokenCreateResponse {
+    job_id: string;
+    status: string;
+    message?: string;
+}
+export interface JobStatusResponse {
+    job_id: number;
+    status: string;
+    chain?: string;
+    token_address?: string;
+    error?: string;
+    created_at?: string;
+    completed_at?: string;
+}
+export interface CreatedTokenItem {
+    token_address: string;
+    name: string;
+    symbol: string;
+    chain: string;
+    platform?: string;
+    created_at?: string;
+}
+export interface CreatedTokensResponse {
+    tokens: CreatedTokenItem[];
+    total: number;
+    page: number;
+    page_size: number;
+    has_more: boolean;
+}
+export interface TokenInfoResponse {
+    address: string;
+    name: string;
+    symbol: string;
+    chain: string;
+    platform: string;
+    token_address?: string;
+    creator_twitter_username?: string;
+    created_at: string;
+    price_usd?: string;
+    market_cap_usd?: string;
+    volume_24h_usd?: string;
+    creator_reward_usd?: string;
+    [key: string]: unknown;
+}
+export interface WalletSlot {
+    address?: string;
+    balance_bnb?: string;
+    balance_usdt_bsc?: string;
+    bnb_error?: string | null;
+    usdt_bsc_error?: string | null;
+}
+export interface WalletBalanceResponse {
+    evm_main: WalletSlot;
+    evm_trading: WalletSlot;
+}
+export interface CreditBalanceResponse {
+    balance_usd: string;
+    agent_reload?: {
+        enabled: boolean;
+        amount_usd: number;
+        daily_limit_usd: number;
+        chains: string[];
+    };
+}
+export interface AgentReloadResponse {
+    amount_usd: string;
+    tx_hash: string;
+    new_balance_usd?: string;
+    daily_used_usd: string;
+    daily_remaining_usd: string;
+}
+export interface ChainQuota {
+    chain: string;
+    free_used_today: number;
+    free_limit: number;
+    sponsored_remaining: number;
+    can_create_paid: boolean;
+    trading_wallet_balance?: string;
+    trading_wallet_address?: string;
+}
+export interface QuotaResponse {
+    chains: ChainQuota[];
+}
+export interface SkillItem {
+    name: string;
+    description: string;
+    example?: string;
+}
+export interface SkillsResponse {
+    skills: SkillItem[];
+    total: number;
+}
+export interface LlmModel {
+    id: string;
+    name?: string;
+    input?: number;
+    output?: number;
+    [key: string]: unknown;
+}
+export interface LlmModelsResponse {
+    models: string[];
+}
+export interface OpenclawConfigResponse {
+    baseUrl: string;
+    api: string;
+    models: LlmModel[];
+}
+export interface FeeSummaryBsc {
+    token_count: number;
+    total_earned_bnb: number;
+}
+export interface FeeSummaryResponse {
+    bsc: FeeSummaryBsc;
+}
+export interface FeeEarningsBsc {
+    chain: 'bsc';
+    flap: {
+        total_earned_bnb: number;
+        earning_token_count: number;
+    };
+    fourmeme: {
+        total_earned_bnb: number;
+        earning_token_count: number;
+    };
+}
+export type FeeEarningsResponse = FeeEarningsBsc;
+export interface FeeTokenBsc {
+    token_name: string;
+    token_symbol: string;
+    token_address: string;
+    platform: string;
+    chain: string;
+    earned_bnb: number;
+}
+export interface FeeTokenUnsupported {
+    supported: false;
+    message: string;
+}
+export type FeeTokenResponse = FeeTokenBsc | FeeTokenUnsupported;

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared TypeScript types for the BFunBot CLI.
+ */
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@bfun-bot/cli",
+  "version": "1.0.5",
+  "description": "BFunBot CLI — deploy tokens, check balances, and manage your AI agent from the terminal",
+  "type": "module",
+  "bin": {
+    "bfunbot": "./bin/bfunbot.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "bin",
+    "scripts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "bfunbot",
+    "bfunbot",
+    "token",
+    "meme",
+    "agent",
+    "cli",
+    "bsc",
+    "bnb"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ora": "^8.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.4"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+const W = 43;
+function pad(text) {
+  return text + ' '.repeat(Math.max(0, W - text.length));
+}
+let version = 'unknown';
+try {
+  const pkg = require('../package.json');
+  version = pkg.version || 'unknown';
+} catch {}
+
+const lines = [
+  '',
+  '   K I B I B O T',
+  '',
+  '   Deploy tokens. Earn fees.',
+  '   Power your AI agent.',
+  '',
+  `   Version    ${version}`,
+  '   Website    kibi.bot',
+  '   Docs       kibi.bot/docs/agent',
+  '   GitHub     github.com/KibiAgent',
+  '',
+  '   Base  ·  BSC  ·  Solana',
+  '',
+];
+
+console.log();
+console.log(`  \x1b[36m╔${'═'.repeat(W)}╗\x1b[0m`);
+for (const line of lines) {
+  console.log(`  \x1b[36m║\x1b[0m${pad(line)}\x1b[36m║\x1b[0m`);
+}
+console.log(`  \x1b[36m╚${'═'.repeat(W)}╝\x1b[0m`);
+console.log();