@bfun-bot/cli 1.0.13 → 1.1.0

package/README.md

@@ -1,6 +1,6 @@
 # BFunBot CLI
 
-Deploy tokens, check balances, and manage your AI agent from the terminal.
+Deploy tokens, check balances, manage your agent profile, and manage your AI agent from the terminal.
 
 ## Installation
 
@@ -44,6 +44,13 @@ bfunbot fees
 | `bfunbot llm credits` | Check BFunBot LLM Credits balance |
 | `bfunbot llm reload` | Reload credits from trading wallet |
 | `bfunbot llm setup openclaw` | Configure OpenClaw integration |
+| `bfunbot profile` | View your agent profile |
+| `bfunbot profile create` | Create a new agent profile |
+| `bfunbot profile update` | Update profile fields |
+| `bfunbot profile submit` | Submit profile for admin review |
+| `bfunbot profile add-project-update` | Add a project update |
+| `bfunbot profile delete-project-update <id>` | Delete a project update |
+| `bfunbot profile delete` | Permanently delete profile |
 | `bfunbot config get` | Show current config |
 | `bfunbot config set` | Set a config value |
 | `bfunbot about` | About BFunBot CLI |
@@ -81,6 +88,70 @@ bfunbot llm credits
 bfunbot llm reload
 ```
 
+## Agent Profile
+
+Manage your public agent profile on [bfun.bot/agent/profiles](https://bfun.bot/agent/profiles). Earnings data (total earnings, token count, top earning tokens) is automatically populated from your BFunBot token history — no manual token linking needed.
+
+```bash
+# View your profile
+bfunbot profile
+bfunbot profile --json
+
+# Create a profile (interactive wizard, prompts to submit for review)
+bfunbot profile create
+
+# Create with flags
+bfunbot profile create --name "My Agent" --description "An autonomous trading bot"
+
+# Update profile fields
+bfunbot profile update --name "New Name"
+bfunbot profile update --description "Updated description"
+
+# Submit for admin review
+bfunbot profile submit
+
+# Project updates (changelog / announcements)
+bfunbot profile add-project-update --title "v2.0" --content "New features are here!"
+bfunbot profile delete-project-update <uuid>
+
+# Delete profile (draft/rejected only)
+bfunbot profile delete
+```
+
+### bfun.toml
+
+Team members and products can be set via a `bfun.toml` file in your project directory. The CLI auto-reads it during `create` and `update`.
+
+```toml
+[profile]
+name        = "My Agent"
+description = "Does something useful on-chain."
+
+[[profile.team_members]]
+name = "Alice"
+role = "Lead Dev"
+links = ["https://twitter.com/alice"]
+
+[[profile.products]]
+name        = "Swap Engine"
+description = "Optimised DEX routing"
+url         = "https://my-agent.xyz/swap"
+```
+
+### Profile status flow
+
+Profiles start as `draft` and must be submitted for admin review before appearing publicly.
+
+| Status | Visible? | Description |
+|---|---|---|
+| `draft` | No | Initial state, editable |
+| `pending_review` | No | Awaiting admin approval |
+| `approved` | Yes | Publicly listed on bfun.bot/agent/profiles |
+| `rejected` | No | Admin rejected — edit and re-submit |
+| `approved_pending_changes` | Yes | Approved profile with edits awaiting review |
+
+Editing an approved profile stores changes as pending — the live version stays public until an admin approves the edits.
+
 ## Global Options
 
 - `--json` — Machine-readable JSON output

package/dist/commands/profile.d.ts

@@ -0,0 +1,7 @@
+/**
+ * bfunbot profile — manage your agent profile on bfun.bot/agent/profiles
+ */
+import { Command } from 'commander';
+/** Coloured status label */
+export declare function fmtStatus(status: string): string;
+export declare function registerProfile(program: Command): void;

package/dist/commands/profile.js

@@ -0,0 +1,394 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { agent, ApiError, handleApiError } from '../lib/api.js';
+import { printCard, printTable, fmtDate, success, warn } from '../lib/display.js';
+import { readBfunToml } from '../lib/toml.js';
+// ─── Helpers ────────────────────────────────────────────
+/** Coloured status label */
+export function fmtStatus(status) {
+    switch (status) {
+        case 'draft': return chalk.yellow('draft');
+        case 'pending_review': return chalk.blue('pending_review');
+        case 'approved': return chalk.green('approved');
+        case 'rejected': return chalk.red('rejected');
+        case 'approved_pending_changes': return chalk.magenta('approved_pending_changes');
+        default: return status;
+    }
+}
+/** Interactive readline helper — reused across subcommands */
+async function interactivePrompts(fields) {
+    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())));
+    const answers = [];
+    for (const field of fields) {
+        if (field.current) {
+            answers.push(field.current);
+            continue;
+        }
+        const suffix = field.required ? ': ' : ' (optional, Enter to skip): ';
+        const answer = await ask(field.label + suffix);
+        answers.push(answer);
+    }
+    rl.close();
+    return answers;
+}
+/** Display a full profile with pending changes awareness */
+function displayProfile(profile) {
+    const showRejection = profile.rejection_reason
+        ? profile.rejection_reason
+        : undefined;
+    printCard(`Profile: ${profile.name}`, [
+        ['Status', fmtStatus(profile.status)],
+        ['Slug', profile.slug],
+        ['Description', profile.description],
+        ['Rejection', showRejection],
+        ['Submitted', fmtDate(profile.submitted_at)],
+        ['Approved', fmtDate(profile.approved_at)],
+        ['Created', fmtDate(profile.created_at)],
+        ['Updated', fmtDate(profile.updated_at)],
+    ]);
+    // Earnings (auto-populated from BFunBot token history)
+    if (profile.total_earnings_usd || profile.total_tokens_created) {
+        printCard('Earnings', [
+            ['Total Earnings', profile.total_earnings_usd ? `$${profile.total_earnings_usd.toFixed(2)}` : '$0.00'],
+            ['Earning Tokens', String(profile.earning_tokens_count || 0)],
+            ['Total Created', String(profile.total_tokens_created || 0)],
+        ]);
+    }
+    // Top earning tokens (BSC only — no chain column needed)
+    if (profile.top_earning_tokens && profile.top_earning_tokens.length > 0) {
+        const rows = profile.top_earning_tokens.map(t => [
+            `${t.token_name} (${t.token_symbol})`,
+            `$${t.creator_reward.toFixed(2)}`,
+            t.market_cap ? `$${t.market_cap.toFixed(0)}` : chalk.dim('—'),
+        ]);
+        console.log(chalk.bold.cyan(`Top Earning Tokens (${profile.top_earning_tokens.length})`));
+        printTable(['Token', 'Earned', 'Mkt Cap'], rows);
+    }
+    // Pending changes banner
+    if (profile.pending_changes) {
+        const changedFields = Object.keys(profile.pending_changes);
+        if (profile.status === 'approved_pending_changes') {
+            warn(`Changes submitted for review: ${changedFields.join(', ')}`);
+        }
+        else if (profile.status === 'approved') {
+            warn(`Unsent changes: ${changedFields.join(', ')}. Run 'bfunbot profile submit' to submit for review.`);
+        }
+        console.log();
+    }
+    // Team members
+    const members = profile.team_members;
+    if (members && members.length > 0) {
+        const rows = members.map(m => [
+            m.name,
+            m.role || chalk.dim('—'),
+            m.links?.join(', ') || chalk.dim('—'),
+        ]);
+        console.log(chalk.bold.cyan(`Team Members (${members.length})`));
+        printTable(['Name', 'Role', 'Links'], rows);
+    }
+    // Products
+    const products = profile.products;
+    if (products && products.length > 0) {
+        const rows = products.map(p => [
+            p.name,
+            p.description || chalk.dim('—'),
+            p.url || chalk.dim('—'),
+        ]);
+        console.log(chalk.bold.cyan(`Products (${products.length})`));
+        printTable(['Name', 'Description', 'URL'], rows);
+    }
+    // Revenue sources (read-only, populated by backend)
+    const revenue = profile.revenue_sources;
+    if (revenue && revenue.length > 0) {
+        const rows = revenue.map(r => [
+            r.name,
+            r.description || chalk.dim('—'),
+        ]);
+        console.log(chalk.bold.cyan(`Revenue Sources (${revenue.length})`));
+        printTable(['Name', 'Description'], rows);
+    }
+    // Project updates
+    const updates = profile.updates;
+    if (updates && updates.length > 0) {
+        const rows = updates.map(u => [
+            chalk.dim(u.id.slice(0, 8)),
+            u.title,
+            fmtDate(u.created_at),
+        ]);
+        console.log(chalk.bold.cyan(`Project Updates (${updates.length})`));
+        printTable(['ID', 'Title', 'Date'], rows);
+    }
+}
+// ─── Command Registration ───────────────────────────────
+export function registerProfile(program) {
+    const profileCmd = program
+        .command('profile')
+        .description('Manage your agent profile on bfun.bot/agent/profiles');
+    // ── bfunbot profile (view) ─────────────────────────────
+    profileCmd
+        .action(async () => {
+        try {
+            const profile = await agent.profileGet();
+            const isJson = program.opts().json;
+            if (isJson) {
+                console.log(JSON.stringify(profile, null, 2));
+                return;
+            }
+            displayProfile(profile);
+        }
+        catch (err) {
+            if (err instanceof ApiError && err.statusCode === 404) {
+                console.log('\nNo profile found. Create one with `bfunbot profile create`.\n');
+                process.exit(0);
+            }
+            handleApiError(err);
+        }
+    });
+    // ── bfunbot profile create ─────────────────────────────
+    profileCmd
+        .command('create')
+        .description('Create a new agent profile')
+        .option('--name <name>', 'Agent name')
+        .option('--description <desc>', 'Project description')
+        .action(async (opts, cmd) => {
+        let toml;
+        try {
+            toml = readBfunToml();
+        }
+        catch (err) {
+            console.error(err.message);
+            process.exit(1);
+        }
+        let spinner;
+        let submitSpinner;
+        try {
+            const isJson = cmd.optsWithGlobals().json;
+            if (toml && !isJson) {
+                console.log(chalk.dim('  Found bfun.toml in current directory.'));
+            }
+            // Merge: flags > toml > prompt
+            let name = opts.name || toml?.name;
+            let description = opts.description || toml?.description;
+            // Interactive prompts for missing fields (skip in --json mode)
+            if (!isJson && (!name || !description)) {
+                const answers = await interactivePrompts([
+                    { label: 'Agent name', current: name, required: true },
+                    { label: 'Description', current: description, required: true },
+                ]);
+                name = answers[0] || name;
+                description = answers[1] || description;
+            }
+            if (!name) {
+                console.error('Error: --name is required.');
+                process.exit(1);
+            }
+            const body = {
+                name,
+                description: description || undefined,
+                team_members: toml?.team_members,
+                products: toml?.products,
+            };
+            spinner = ora('Creating profile...').start();
+            const profile = await agent.profileCreate(body);
+            spinner.stop();
+            if (isJson) {
+                console.log(JSON.stringify(profile, null, 2));
+                return;
+            }
+            displayProfile(profile);
+            // Prompt to submit for review
+            const readline = await import('node:readline');
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const submitAnswer = await new Promise((resolve) => rl.question('Submit for review now? (y/n): ', (a) => resolve(a.trim().toLowerCase())));
+            rl.close();
+            if (submitAnswer === 'y' || submitAnswer === 'yes') {
+                submitSpinner = ora('Submitting for review...').start();
+                await agent.profileSubmit();
+                submitSpinner.stop();
+                success('Profile submitted for review.');
+                console.log(chalk.dim("  Check your status at bfun.bot or run 'bfunbot profile'.\n"));
+            }
+            else {
+                console.log(chalk.dim("  Run 'bfunbot profile submit' when ready for review.\n"));
+            }
+        }
+        catch (err) {
+            spinner?.stop();
+            submitSpinner?.stop();
+            if (err instanceof ApiError && err.statusCode === 409) {
+                console.error('Error: Profile already exists. Use `bfunbot profile update` to modify it.');
+                process.exit(1);
+            }
+            handleApiError(err);
+        }
+    });
+    // ── bfunbot profile update ─────────────────────────────
+    profileCmd
+        .command('update')
+        .description('Update your agent profile')
+        .option('--name <name>', 'Agent name')
+        .option('--description <desc>', 'Project description')
+        .action(async (opts, cmd) => {
+        let toml;
+        try {
+            toml = readBfunToml();
+        }
+        catch (err) {
+            console.error(err.message);
+            process.exit(1);
+        }
+        let spinner;
+        try {
+            const isJson = cmd.optsWithGlobals().json;
+            if (toml && !isJson) {
+                console.log(chalk.dim('  Found bfun.toml in current directory.'));
+            }
+            const body = {};
+            // Flags take priority
+            if (opts.name)
+                body.name = opts.name;
+            else if (toml?.name)
+                body.name = toml.name;
+            if (opts.description)
+                body.description = opts.description;
+            else if (toml?.description)
+                body.description = toml.description;
+            // Merge TOML array fields
+            if (toml?.team_members)
+                body.team_members = toml.team_members;
+            if (toml?.products)
+                body.products = toml.products;
+            if (Object.keys(body).length === 0) {
+                console.error('Error: No fields to update. Provide flags or a bfun.toml file.');
+                process.exit(1);
+            }
+            spinner = ora('Updating profile...').start();
+            const profile = await agent.profileUpdate(body);
+            spinner.stop();
+            if (isJson) {
+                console.log(JSON.stringify(profile, null, 2));
+                return;
+            }
+            displayProfile(profile);
+        }
+        catch (err) {
+            spinner?.stop();
+            handleApiError(err);
+        }
+    });
+    // ── bfunbot profile submit ─────────────────────────────
+    profileCmd
+        .command('submit')
+        .description('Submit profile for admin review')
+        .action(async () => {
+        let spinner;
+        try {
+            const isJson = program.opts().json;
+            spinner = ora('Submitting for review...').start();
+            const profile = await agent.profileSubmit();
+            spinner.stop();
+            if (isJson) {
+                console.log(JSON.stringify(profile, null, 2));
+                return;
+            }
+            if (profile.status === 'approved_pending_changes') {
+                success('Pending changes submitted for review. Your approved profile stays live.');
+            }
+            else {
+                success('Profile submitted for review.');
+            }
+            console.log(chalk.dim("  Check your status at bfun.bot or run 'bfunbot profile'.\n"));
+        }
+        catch (err) {
+            spinner?.stop();
+            handleApiError(err);
+        }
+    });
+    // ── bfunbot profile add-project-update ──────────────────
+    profileCmd
+        .command('add-project-update')
+        .description('Add a project update to your profile')
+        .option('--title <title>', 'Update title')
+        .option('--content <content>', 'Update content')
+        .action(async (opts, cmd) => {
+        try {
+            const isJson = cmd.optsWithGlobals().json;
+            let { title, content } = opts;
+            // Interactive prompts for missing fields
+            if (!isJson && (!title || !content)) {
+                const answers = await interactivePrompts([
+                    { label: 'Title', current: title, required: true },
+                    { label: 'Content', current: content, required: true },
+                ]);
+                title = answers[0] || title;
+                content = answers[1] || content;
+            }
+            if (!title || !content) {
+                console.error('Error: --title and --content are required.');
+                process.exit(1);
+            }
+            const result = await agent.profileAddUpdate({ title, content });
+            if (isJson) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            success(`Project update added: "${result.title}"`);
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+    // ── bfunbot profile delete-project-update <id> ──────────
+    profileCmd
+        .command('delete-project-update <id>')
+        .description('Delete a project update')
+        .action(async (id) => {
+        try {
+            await agent.profileDeleteUpdate(id);
+            const isJson = program.opts().json;
+            if (isJson) {
+                console.log(JSON.stringify({ deleted: true, id }, null, 2));
+                return;
+            }
+            success(`Project update ${id} deleted.`);
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+    // ── bfunbot profile delete ─────────────────────────────
+    profileCmd
+        .command('delete')
+        .description('Permanently delete your agent profile')
+        .option('--yes', 'Skip confirmation prompt')
+        .action(async (opts, cmd) => {
+        let spinner;
+        try {
+            const isJson = cmd.optsWithGlobals().json;
+            if (!opts.yes && !isJson) {
+                const readline = await import('node:readline');
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                const answer = await new Promise((resolve) => rl.question(chalk.red("Type 'delete' to confirm permanent deletion: "), (a) => resolve(a.trim())));
+                rl.close();
+                if (answer !== 'delete') {
+                    console.log('Cancelled.');
+                    return;
+                }
+            }
+            spinner = ora('Deleting profile...').start();
+            await agent.profileDelete();
+            spinner.stop();
+            if (isJson) {
+                console.log(JSON.stringify({ deleted: true }, null, 2));
+                return;
+            }
+            success('Profile deleted.');
+        }
+        catch (err) {
+            spinner?.stop();
+            handleApiError(err);
+        }
+    });
+}

package/dist/index.js

@@ -21,6 +21,7 @@ import { registerLlm } from './commands/llm.js';
 import { registerConfig } from './commands/config.js';
 import { registerAbout } from './commands/about.js';
 import { registerFees } from './commands/fees.js';
+import { registerProfile } from './commands/profile.js';
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -81,4 +82,5 @@ registerLlm(program);
 registerConfig(program);
 registerAbout(program);
 registerFees(program);
+registerProfile(program);
 program.parse();

package/dist/lib/api.d.ts

@@ -25,6 +25,13 @@ export declare const agent: {
     feesSummary: () => Promise<import("../types.js").FeeSummaryResponse>;
     feesEarnings: (chain: string) => Promise<import("../types.js").FeeEarningsBsc>;
     feesToken: (chain: string, platform: string, tokenAddress: string) => Promise<import("../types.js").FeeTokenResponse>;
+    profileGet: () => Promise<import("../types.js").ProfileResponse>;
+    profileCreate: (body: import("../types.js").ProfileCreateRequest) => Promise<import("../types.js").ProfileResponse>;
+    profileUpdate: (body: import("../types.js").ProfileUpdateRequest) => Promise<import("../types.js").ProfileResponse>;
+    profileSubmit: () => Promise<import("../types.js").ProfileResponse>;
+    profileDelete: () => Promise<void>;
+    profileAddUpdate: (body: import("../types.js").ProjectUpdateCreateRequest) => Promise<import("../types.js").ProjectUpdateResponse>;
+    profileDeleteUpdate: (updateId: string) => Promise<void>;
 };
 export declare const llm: {
     models: () => Promise<import("../types.js").LlmModelsResponse>;

package/dist/lib/api.js

@@ -92,7 +92,7 @@ async function request(path, opts = {}) {
     const config = readConfig();
     const baseUrl = baseLlm
         ? (config.llmUrl || 'https://llm.bfun.bot/v1')
-        : (config.apiUrl || 'https://api.bfun.bot');
+        : (process.env['BFUN_API_URL'] || config.apiUrl || 'https://api.bfun.bot');
     const url = `${baseUrl}${path}`;
     const headers = {
         'Accept': 'application/json',
@@ -168,6 +168,26 @@ export const agent = {
     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)}`),
+    // Profile
+    profileGet: () => request('/agent/v1/profile'),
+    profileCreate: (body) => request('/agent/v1/profile', {
+        method: 'POST',
+        body,
+    }),
+    profileUpdate: (body) => request('/agent/v1/profile', {
+        method: 'PUT',
+        body,
+    }),
+    profileSubmit: () => request('/agent/v1/profile/submit', {
+        method: 'POST',
+        body: {},
+    }),
+    profileDelete: () => request('/agent/v1/profile', { method: 'DELETE' }),
+    profileAddUpdate: (body) => request('/agent/v1/profile/update', {
+        method: 'POST',
+        body,
+    }),
+    profileDeleteUpdate: (updateId) => request(`/agent/v1/profile/updates/${updateId}`, { method: 'DELETE' }),
 };
 // LLM Gateway (base: /llm/v1)
 export const llm = {

package/dist/lib/toml.d.ts

@@ -0,0 +1,12 @@
+import type { ProfileTeamMember, ProfileProduct } from '../types.js';
+export interface BfunTomlProfile {
+    name?: string;
+    description?: string;
+    team_members?: ProfileTeamMember[];
+    products?: ProfileProduct[];
+}
+/**
+ * Read bfun.toml from CWD. Returns undefined if the file does not exist.
+ * Throws with a friendly message if the file exists but cannot be parsed.
+ */
+export declare function readBfunToml(): BfunTomlProfile | undefined;

package/dist/lib/toml.js

@@ -0,0 +1,48 @@
+/**
+ * Reads bfun.toml from the current working directory.
+ *
+ * Supports a [profile] section with scalar fields (name, description)
+ * and array fields (team_members, products).
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse } from 'smol-toml';
+/**
+ * Read bfun.toml from CWD. Returns undefined if the file does not exist.
+ * Throws with a friendly message if the file exists but cannot be parsed.
+ */
+export function readBfunToml() {
+    const tomlPath = join(process.cwd(), 'bfun.toml');
+    if (!existsSync(tomlPath))
+        return undefined;
+    let raw;
+    try {
+        raw = readFileSync(tomlPath, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Error parsing bfun.toml: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const profile = parsed.profile;
+    if (!profile)
+        return undefined;
+    // Validate array element shapes — filter out malformed entries
+    const team_members = Array.isArray(profile.team_members)
+        ? profile.team_members.filter((m) => typeof m === 'object' && m !== null && typeof m.name === 'string')
+        : undefined;
+    const products = Array.isArray(profile.products)
+        ? profile.products.filter((p) => typeof p === 'object' && p !== null && typeof p.name === 'string')
+        : undefined;
+    return {
+        name: typeof profile.name === 'string' ? profile.name : undefined,
+        description: typeof profile.description === 'string' ? profile.description : undefined,
+        team_members: team_members && team_members.length > 0 ? team_members : undefined,
+        products: products && products.length > 0 ? products : undefined,
+    };
+}

package/dist/types.d.ts

@@ -172,3 +172,80 @@ export interface FeeTokenUnsupported {
     message: string;
 }
 export type FeeTokenResponse = FeeTokenBsc | FeeTokenUnsupported;
+export interface ProfileTeamMember {
+    name: string;
+    role?: string;
+    links?: string[];
+}
+export interface ProfileProduct {
+    name: string;
+    description?: string;
+    url?: string;
+}
+export interface ProfileRevenueSource {
+    name: string;
+    description?: string;
+}
+export interface ProfileUpdate {
+    id: string;
+    title: string;
+    content: string;
+    created_at: string;
+}
+export interface TopEarningToken {
+    token_address: string;
+    token_name: string;
+    token_symbol: string;
+    chain_id: number;
+    image_url?: string;
+    platform: string;
+    creator_reward: number;
+    creator_reward_24h: number;
+    market_cap?: number;
+    price_usd: number;
+}
+export interface ProfileResponse {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    twitter_username?: string;
+    profile_image_url?: string;
+    team_members?: ProfileTeamMember[];
+    products?: ProfileProduct[];
+    revenue_sources?: ProfileRevenueSource[];
+    total_earnings_usd?: number;
+    earning_tokens_count?: number;
+    total_tokens_created?: number;
+    top_earning_tokens?: TopEarningToken[];
+    status: string;
+    rejection_reason?: string;
+    pending_changes?: Record<string, unknown> | null;
+    submitted_at?: string;
+    approved_at?: string;
+    featured?: boolean;
+    updates?: ProfileUpdate[];
+    created_at?: string;
+    updated_at?: string;
+}
+export interface ProfileCreateRequest {
+    name: string;
+    description?: string;
+    team_members?: ProfileTeamMember[];
+    products?: ProfileProduct[];
+}
+export interface ProfileUpdateRequest {
+    name?: string;
+    description?: string;
+    team_members?: ProfileTeamMember[];
+    products?: ProfileProduct[];
+}
+export interface ProjectUpdateCreateRequest {
+    title: string;
+    content: string;
+}
+export interface ProjectUpdateResponse {
+    id: string;
+    title: string;
+    content: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bfun-bot/cli",
-  "version": "1.0.13",
+  "version": "1.1.0",
   "description": "BFunBot CLI — deploy tokens, check balances, and manage your AI agent from the terminal",
   "type": "module",
   "bin": {
@@ -40,6 +40,7 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "ora": "^8.1.1",
+    "smol-toml": "^1.6.1",
     "string-width": "^8.2.0"
   },
   "devDependencies": {