@kibibot/cli 1.0.0

package/dist/commands/status.js

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

package/dist/commands/token.d.ts

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

package/dist/commands/token.js

@@ -0,0 +1,140 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { agent, handleApiError } from '../lib/api.js';
+import { printCard, fmtUsd, fmtDate } from '../lib/display.js';
+const POLL_INTERVAL_MS = 2000;
+const POLL_TIMEOUT_MS = 120_000;
+const EXPLORER_URLS = {
+    base: 'https://basescan.org/token/',
+    bsc: 'https://bscscan.com/token/',
+    solana: 'https://solscan.io/token/',
+};
+export function registerToken(program) {
+    const tokenCmd = program
+        .command('token')
+        .description('Token creation and info');
+    // ── token create ──────────────────────────────────────
+    tokenCmd
+        .command('create')
+        .description('Deploy a new token')
+        .option('--name <name>', 'Token name')
+        .option('--symbol <symbol>', 'Token symbol')
+        .option('--chain <chain>', 'Chain: base, bsc, or solana')
+        .option('--description <desc>', 'Token description')
+        .option('--image-url <url>', 'Image URL (HTTPS or IPFS)')
+        .option('--platform <platform>', 'Platform override')
+        .option('--no-wait', 'Return job ID without waiting for deployment')
+        .action(async (opts, cmd) => {
+        try {
+            let { name, symbol, chain } = opts;
+            const isJson = cmd.optsWithGlobals().json;
+            // Interactive prompts for missing required fields
+            if (!name || !symbol || !chain) {
+                const readline = await import('node:readline');
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                const ask = (q) => new Promise((resolve) => rl.question(q, (a) => resolve(a.trim())));
+                if (!name)
+                    name = await ask('Token name: ');
+                if (!symbol)
+                    symbol = await ask('Symbol: ');
+                if (!chain)
+                    chain = await ask('Chain (base/bsc/solana): ');
+                rl.close();
+            }
+            // Validate chain
+            chain = chain.toLowerCase();
+            const VALID_CHAINS = ['base', 'bsc', 'solana'];
+            if (!VALID_CHAINS.includes(chain)) {
+                console.error(`Error: Chain must be one of: ${VALID_CHAINS.join(', ')}`);
+                process.exit(1);
+            }
+            const spinner = ora('Creating token...').start();
+            const result = await agent.tokenCreate({
+                name,
+                symbol: symbol.toUpperCase(),
+                chain,
+                description: opts.description,
+                image_url: opts.imageUrl,
+                platform: opts.platform,
+            });
+            spinner.succeed(`Job created (ID: ${result.job_id})`);
+            if (!opts.wait) {
+                if (isJson) {
+                    console.log(JSON.stringify(result, null, 2));
+                }
+                else {
+                    console.log(`  Check status with: ${chalk.cyan(`kibi status ${result.job_id}`)}`);
+                }
+                return;
+            }
+            // Poll for completion
+            const pollSpinner = ora('Waiting for deployment...').start();
+            const startTime = Date.now();
+            while (Date.now() - startTime < POLL_TIMEOUT_MS) {
+                await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                pollSpinner.text = `Waiting for deployment... (${elapsed}s)`;
+                const job = await agent.jobStatus(String(result.job_id));
+                if (job.status === 'completed' && job.token_address) {
+                    pollSpinner.succeed('Token deployed!');
+                    if (isJson) {
+                        console.log(JSON.stringify(job, null, 2));
+                        return;
+                    }
+                    const explorerBase = EXPLORER_URLS[chain] || '';
+                    printCard('Token Deployed', [
+                        ['Address', job.token_address],
+                        ['Chain', chain.charAt(0).toUpperCase() + chain.slice(1)],
+                        ['View', explorerBase ? `${explorerBase}${job.token_address}` : undefined],
+                    ]);
+                    return;
+                }
+                if (job.status === 'failed') {
+                    pollSpinner.fail('Token creation failed');
+                    console.error(`  ${job.error || 'Unknown error'}`);
+                    process.exit(1);
+                }
+            }
+            // Timeout
+            pollSpinner.warn('Token creation still in progress');
+            console.log(`  Check status with: ${chalk.cyan(`kibi status ${result.job_id}`)}`);
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+    // ── token info ────────────────────────────────────────
+    tokenCmd
+        .command('info <address>')
+        .description('Get token details')
+        .option('--chain <chain>', 'Chain hint (base, bsc, solana)')
+        .action(async (address, opts, cmd) => {
+        try {
+            const res = await agent.tokenInfo(address, opts.chain);
+            const isJson = cmd.optsWithGlobals().json;
+            if (isJson) {
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const explorerBase = EXPLORER_URLS[res.chain] || '';
+            printCard(`${res.symbol} — ${res.name}`, [
+                ['Address', res.token_address],
+                ['Chain', res.chain],
+                ['Platform', res.platform],
+                ['Creator', res.creator_twitter_username ? `@${res.creator_twitter_username}` : undefined],
+                ['Price', fmtUsd(res.price_usd)],
+                ['Market Cap', fmtUsd(res.market_cap_usd)],
+                ['24h Volume', fmtUsd(res.volume_24h_usd)],
+                ['Creator Reward', fmtUsd(res.creator_reward_usd)],
+                ['Created', fmtDate(res.created_at)],
+                ['Explorer', explorerBase ? `${explorerBase}${res.token_address}` : undefined],
+            ]);
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+}

package/dist/commands/tokens.d.ts

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

package/dist/commands/tokens.js

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

package/dist/commands/whoami.d.ts

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

package/dist/commands/whoami.js

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+/**
+ * KibiBot CLI — deploy tokens, check balances, and manage your AI agent.
+ *
+ * @package @kibibot/cli
+ */
+import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { enableDebug } from './lib/api.js';
+import { registerLogin } from './commands/login.js';
+import { registerWhoami } from './commands/whoami.js';
+import { registerTokens } from './commands/tokens.js';
+import { registerToken } from './commands/token.js';
+import { registerStatus } from './commands/status.js';
+import { registerBalances } from './commands/balances.js';
+import { registerQuota } from './commands/quota.js';
+import { registerSkills } from './commands/skills.js';
+import { registerLlm } from './commands/llm.js';
+import { registerConfig } from './commands/config.js';
+// Read version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+const program = new Command();
+program
+    .name('kibi')
+    .description('KibiBot CLI — deploy tokens, check balances, and manage your AI agent')
+    .version(pkg.version)
+    .option('--json', 'Output raw JSON (machine-readable)')
+    .option('--debug', 'Verbose HTTP request/response logging')
+    .hook('preAction', (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    if (opts.debug) {
+        enableDebug();
+    }
+});
+// Register all commands
+registerLogin(program);
+registerWhoami(program);
+registerTokens(program);
+registerToken(program);
+registerStatus(program);
+registerBalances(program);
+registerQuota(program);
+registerSkills(program);
+registerLlm(program);
+registerConfig(program);
+program.parse();

package/dist/lib/api.d.ts

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

package/dist/lib/api.js

@@ -0,0 +1,152 @@
+/**
+ * HTTP client for the KibiBot 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 'kibi 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:
+            return 'Rate limited. Try again later.';
+        default:
+            if (err.statusCode >= 500) {
+                return 'Server error. Try again later.';
+            }
+            return err.body?.detail || 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) {
+        // Network errors (fetch rejects with TypeError on connection failure)
+        console.error('Error: Could not reach KibiBot 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.kibi.bot/v1')
+        : (config.apiUrl || 'https://kibi.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'),
+    kibiCreditBalance: () => request('/agent/v1/balance/credits'),
+    reloadKibiCredits: () => 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 }),
+};
+// LLM Gateway (base: /llm/v1)
+export const llm = {
+    models: () => request('/models', {
+        baseLlm: true,
+        auth: false,
+    }),
+};

package/dist/lib/config.d.ts

@@ -0,0 +1,31 @@
+import type { KibiConfig } from '../types.js';
+declare const CONFIG_DIR: string;
+declare const CONFIG_PATH: string;
+declare const DEFAULT_API_URL = "https://kibi.bot";
+declare const DEFAULT_LLM_URL = "https://llm.kibi.bot/v1";
+/**
+ * Read config from disk. Returns defaults for missing values.
+ */
+export declare function readConfig(): KibiConfig;
+/**
+ * Write config to disk. Merges with existing config.
+ * Creates ~/.kibi/ if needed. Sets file permissions to 0600.
+ */
+export declare function writeConfig(updates: Partial<KibiConfig>): void;
+/**
+ * Delete config file (logout).
+ */
+export declare function clearConfig(): void;
+/**
+ * Get a specific config value.
+ */
+export declare function getConfigValue(key: keyof KibiConfig): string | undefined;
+/**
+ * Set a specific config value.
+ */
+export declare function setConfigValue(key: keyof KibiConfig, 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 ~/.kibi/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(), '.kibi');
+const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+const DEFAULT_API_URL = 'https://kibi.bot';
+const DEFAULT_LLM_URL = 'https://llm.kibi.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 ~/.kibi/ 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['KIBI_API_KEY'];
+    if (envKey)
+        return envKey;
+    const config = readConfig();
+    if (!config.apiKey) {
+        console.error('Error: Not logged in. Run `kibi 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;