@kibibot/cli 1.0.0

package/README.md

@@ -0,0 +1,148 @@
+# @kibibot/cli
+
+The official KibiBot command-line interface. Deploy tokens on-chain, check balances, manage Kibi Credits, and control your AI agent from the terminal.
+
+## Installation
+
+```bash
+npm install -g @kibibot/cli
+```
+
+```bash
+kibi --version
+```
+
+### Run without installing
+
+```bash
+npx @kibibot/cli whoami
+npx @kibibot/cli token create --name MyToken --symbol MTK --chain base
+```
+
+## Setup
+
+### 1. Get an API key
+
+Go to [kibi.bot/settings/api-keys](https://kibi.bot/settings/api-keys) → Create API Key → copy the `kb_...` key.
+
+### 2. Login
+
+```bash
+# Interactive — prompts for API key
+kibi login
+
+# Headless — pass key directly
+kibi login --api-key kb_YOUR_KEY
+```
+
+Credentials are stored in `~/.kibi/config.json`. You can also set `KIBI_API_KEY` as an environment variable.
+
+### 3. Verify
+
+```bash
+kibi whoami
+```
+
+## Commands
+
+### Identity
+
+```bash
+kibi whoami          # your account info and wallet addresses
+kibi logout          # clear stored credentials
+```
+
+### Token Creation
+
+```bash
+# Interactive (prompts for name, symbol, chain)
+kibi token create
+
+# Headless
+kibi token create --name "MyToken" --symbol MTK --chain base
+kibi token create --name "Moon" --symbol MOON --chain solana --description "To the moon"
+kibi token create --name "Test" --symbol TST --chain base --no-wait  # return job ID immediately
+
+# Check deployment status
+kibi status 12345
+
+# Get token info
+kibi token info 0x1234...
+kibi token info 5Yz8K... --chain solana
+
+# List tokens you've created
+kibi tokens created
+kibi tokens created --page 2
+```
+
+Supported chains: `base` · `bsc` · `solana`
+
+### Balances & Quota
+
+```bash
+kibi balances        # on-chain wallet balances across all chains
+kibi quota           # daily token creation quota per chain
+```
+
+### Kibi Credits & Kibi LLM Gateway
+
+```bash
+# Check Kibi Credit balance + agent reload config
+kibi llm credits
+
+# List available AI models
+kibi llm models
+
+# Reload Kibi Credits from trading wallet (requires Agent Reload enabled)
+kibi llm reload
+
+# Emergency disable agent reload
+kibi llm reload --disable
+
+# Generate provider config for your tool
+kibi llm setup openclaw   # OpenClaw config JSON (use with --install to write directly)
+kibi llm setup cursor     # Cursor IDE settings
+kibi llm setup claude     # Claude Code env vars
+```
+
+### Skills & Config
+
+```bash
+kibi skills          # list all agent capabilities
+
+kibi config get           # show all config
+kibi config get apiKey    # show specific key
+kibi config set apiUrl https://custom.api.url
+```
+
+## Global Flags
+
+| Flag | Description |
+|---|---|
+| `--json` | Machine-readable JSON output |
+| `--debug` | Verbose HTTP request/response logging |
+| `--version` | Print version |
+| `--help` | Print help |
+
+## Configuration
+
+Config precedence (highest to lowest):
+
+1. **Environment variable** — `KIBI_API_KEY`
+2. **Config file** — `~/.kibi/config.json`
+3. **Defaults** — API URL: `https://api.kibi.bot`, LLM URL: `https://llm.kibi.bot`
+
+## Requirements
+
+- Node.js >= 18.0.0
+
+## Links
+
+- [Agent & Developer Docs](https://kibi.bot/docs/agent)
+- [API Keys](https://kibi.bot/settings/api-keys)
+- [Kibi Credits](https://kibi.bot/credits)
+- [GitHub Skills](https://github.com/OfficialKibiBot/skills)
+
+## License
+
+MIT

package/bin/kibi.js

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

package/dist/commands/balances.d.ts

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

package/dist/commands/balances.js

@@ -0,0 +1,60 @@
+import chalk from 'chalk';
+import { agent, handleApiError } from '../lib/api.js';
+import { fmtBalance, shortAddr } from '../lib/display.js';
+function printWallet(label, slot, kind) {
+    if (!slot.address) {
+        console.log(`  ${chalk.dim(label + ':')}  ${chalk.dim('Not configured')}`);
+        return;
+    }
+    console.log(`  ${chalk.bold(label)}  ${chalk.dim(shortAddr(slot.address))}`);
+    // Show only relevant balances per wallet type
+    const balances = kind === 'evm'
+        ? [
+            ['ETH (Base)', slot.balance_eth, slot.eth_error],
+            ['BNB (BSC)', slot.balance_bnb, slot.bnb_error],
+            ['USDC (Base)', slot.balance_usdc_base, slot.usdc_base_error],
+            ['USDT (BSC)', slot.balance_usdt_bsc, slot.usdt_bsc_error],
+        ]
+        : [
+            ['SOL', slot.balance_sol, slot.sol_error],
+            ['USDC (Sol)', slot.balance_usdc_solana, slot.usdc_solana_error],
+        ];
+    // Always show native balances (even if zero); show stablecoins only if > 0
+    const nativeTokens = kind === 'evm' ? ['ETH (Base)', 'BNB (BSC)'] : ['SOL'];
+    for (const [name, value, error] of balances) {
+        if (error) {
+            console.log(`    ${name.padEnd(14)} ${chalk.red('error')}`);
+        }
+        else if (nativeTokens.includes(name) || (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 across all chains')
+        .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, 'evm');
+            printWallet('EVM Trading', res.evm_trading, 'evm');
+            printWallet('Solana Main', res.solana_main, 'solana');
+            printWallet('Solana Trading', res.solana_trading, 'solana');
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * kibi config get / kibi 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', 'apiUrl', 'llmUrl'];
+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:')}  ${config.apiUrl || chalk.dim('(not set)')}`);
+        console.log(`  ${chalk.dim('llmUrl:')}  ${config.llmUrl || chalk.dim('(not set)')}`);
+        console.log();
+    });
+    configCmd
+        .command('set <key> <value>')
+        .description('Set a config value (apiKey, apiUrl, llmUrl)')
+        .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/llm.d.ts

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

package/dist/commands/llm.js

@@ -0,0 +1,229 @@
+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 Kibi Credit balance')
+        .action(async (_, cmd) => {
+        try {
+            const res = await agent.kibiCreditBalance();
+            const isJson = cmd.optsWithGlobals().json;
+            if (isJson) {
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            printCard('Kibi 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 Kibi 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 KibiBot dashboard.');
+                }
+                return;
+            }
+            const isJson = cmd.optsWithGlobals().json;
+            const spinner = ora('Reloading Kibi Credits from trading wallet...').start();
+            const res = await agent.reloadKibiCredits();
+            if (isJson) {
+                spinner.stop();
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            spinner.succeed('Reload complete!');
+            printCard('Kibi 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 coding tools (cursor, claude, openclaw)')
+        .option('--install', 'Write config directly (openclaw only)')
+        .action(async (target, opts, cmd) => {
+        const config = readConfig();
+        const apiKey = config.apiKey || process.env['KIBI_API_KEY'];
+        const llmUrl = config.llmUrl || 'https://llm.kibi.bot/v1';
+        if (!apiKey) {
+            console.error("Error: Not logged in. Run 'kibi login' first.");
+            process.exit(1);
+        }
+        switch (target.toLowerCase()) {
+            case 'cursor': {
+                console.log();
+                console.log(chalk.bold.cyan('Cursor IDE Configuration'));
+                console.log(chalk.dim('─'.repeat(40)));
+                console.log();
+                console.log('Add this to your Cursor settings (Settings → Models → OpenAI API Key):');
+                console.log();
+                console.log(`  ${chalk.bold('API Base URL:')}  ${llmUrl}`);
+                console.log(`  ${chalk.bold('API Key:')}       ${apiKey}`);
+                console.log();
+                console.log(chalk.yellow('⚠ Your API key is shown above. Do not share this output.'));
+                console.log(chalk.dim('Then select a Kibi model from the model dropdown.'));
+                console.log();
+                break;
+            }
+            case 'claude': {
+                console.log();
+                console.log(chalk.bold.cyan('Claude Code Configuration'));
+                console.log(chalk.dim('─'.repeat(40)));
+                console.log();
+                console.log('Set these environment variables:');
+                console.log();
+                console.log(`  export ANTHROPIC_BASE_URL="${llmUrl}"`);
+                console.log(`  export ANTHROPIC_API_KEY="${apiKey}"`);
+                console.log();
+                console.log(chalk.yellow('⚠ Your API key is shown above. Do not share this output.'));
+                console.log(chalk.dim('Then run `claude` as usual.'));
+                console.log();
+                break;
+            }
+            case 'openclaw': {
+                const openclawConfig = {
+                    models: {
+                        mode: 'merge',
+                        providers: {
+                            kibi: {
+                                baseUrl: llmUrl.replace('/v1', ''),
+                                apiKey: apiKey,
+                                api: 'openai-completions',
+                                models: [
+                                    { id: 'claude-haiku-4-5', name: 'Claude Haiku (KibiBot)', api: 'anthropic-messages', contextWindow: 200000, maxTokens: 4096 },
+                                    { id: 'claude-sonnet-4-6', name: 'Claude Sonnet (KibiBot)', api: 'anthropic-messages', contextWindow: 200000, maxTokens: 8192 },
+                                    { id: 'claude-opus-4-6', name: 'Claude Opus (KibiBot)', api: 'anthropic-messages', contextWindow: 200000, maxTokens: 8192 },
+                                    { id: 'gpt-4o', name: 'GPT-4o (KibiBot)', contextWindow: 128000, maxTokens: 16384 },
+                                    { id: 'gpt-4o-mini', name: 'GPT-4o Mini (KibiBot)', contextWindow: 128000, maxTokens: 16384 },
+                                    { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash (KibiBot)', contextWindow: 1048576, maxTokens: 8192 },
+                                    { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro (KibiBot)', contextWindow: 1048576, maxTokens: 8192 },
+                                ],
+                            },
+                        },
+                    },
+                };
+                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 into models.providers
+                        existing.models = existing.models || {};
+                        existing.models.mode = 'merge';
+                        existing.models.providers = existing.models.providers || {};
+                        existing.models.providers.kibi = openclawConfig.models.providers.kibi;
+                        writeFileSync(configPath, JSON.stringify(existing, null, 2) + '\n', 'utf-8');
+                        success(`Kibi 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: kibi llm setup openclaw --install'));
+                    console.log();
+                }
+                break;
+            }
+            default:
+                console.error(`Error: Unknown target '${target}'. Supported: cursor, claude, openclaw`);
+                process.exit(1);
+        }
+    });
+}

package/dist/commands/login.d.ts

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

package/dist/commands/login.js

@@ -0,0 +1,68 @@
+import chalk from 'chalk';
+import { writeConfig, clearConfig, CONFIG_PATH } from '../lib/config.js';
+import { agent, handleApiError } from '../lib/api.js';
+import { success } from '../lib/display.js';
+export function registerLogin(program) {
+    program
+        .command('login')
+        .description('Authenticate with your KibiBot API key')
+        .option('--api-key <key>', 'API key (kb_...)')
+        .option('--url', 'Open the KibiBot API keys page in your browser')
+        .action(async (opts) => {
+        if (opts.url) {
+            const url = 'https://kibi.bot/settings/api-keys';
+            console.log(`Open this URL to get your API key:\n\n  ${chalk.cyan(url)}\n`);
+            // Try to open browser
+            try {
+                const { exec } = await import('node:child_process');
+                const cmd = process.platform === 'darwin' ? 'open'
+                    : process.platform === 'win32' ? 'start'
+                        : 'xdg-open';
+                exec(`${cmd} ${url}`);
+            }
+            catch {
+                // browser open is best-effort
+            }
+            return;
+        }
+        let apiKey = opts.apiKey;
+        if (!apiKey) {
+            // Interactive prompt
+            const readline = await import('node:readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            apiKey = await new Promise((resolve) => {
+                rl.question('Enter your API key: ', (answer) => {
+                    rl.close();
+                    resolve(answer.trim());
+                });
+            });
+        }
+        if (!apiKey || !apiKey.startsWith('kb_')) {
+            console.error('Error: Invalid API key. Keys start with kb_');
+            process.exit(1);
+        }
+        // Save key first so the API call can use it
+        writeConfig({ apiKey });
+        // Verify the key works
+        try {
+            const me = await agent.me();
+            success(`Logged in as ${chalk.bold('@' + (me.twitter_username || me.twitter_user_id))}`);
+            console.log(`  Config saved to ${chalk.dim(CONFIG_PATH)}`);
+        }
+        catch (err) {
+            // Key is bad — clear it
+            clearConfig();
+            handleApiError(err);
+        }
+    });
+    program
+        .command('logout')
+        .description('Clear stored credentials')
+        .action(() => {
+        clearConfig();
+        success('Logged out. Credentials cleared.');
+    });
+}

package/dist/commands/quota.d.ts

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

package/dist/commands/quota.js

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

package/dist/commands/skills.d.ts

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

package/dist/commands/skills.js

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

package/dist/commands/status.d.ts

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