@bankr/cli 0.1.0-beta.6 → 0.1.0

package/dist/commands/launch.d.ts

@@ -0,0 +1,13 @@
+export interface LaunchOptions {
+    name?: string;
+    symbol?: string;
+    image?: string;
+    tweet?: string;
+    website?: string;
+    fee?: string;
+    feeType?: string;
+    yes?: boolean;
+    simulate?: boolean;
+}
+export declare function launchCommand(options: LaunchOptions): Promise<void>;
+//# sourceMappingURL=launch.d.ts.map

package/dist/commands/launch.js

@@ -0,0 +1,174 @@
+import { confirm, input, select } from "@inquirer/prompts";
+import { deployToken } from "../lib/api.js";
+import { emitCESP } from "../lib/cesp/engine.js";
+import { requireApiKey } from "../lib/config.js";
+import * as output from "../lib/output.js";
+const VALID_FEE_TYPES = ["x", "farcaster", "ens", "wallet"];
+function parseFeeType(value) {
+    if (!value)
+        return "x";
+    const lower = value.toLowerCase();
+    if (VALID_FEE_TYPES.includes(lower))
+        return lower;
+    output.warn(`Unknown fee type "${value}". Valid types: ${VALID_FEE_TYPES.join(", ")}. Defaulting to "x".`);
+    return "x";
+}
+function feeTypeLabel(type) {
+    switch (type) {
+        case "x":
+            return "X";
+        case "farcaster":
+            return "Farcaster";
+        case "ens":
+            return "ENS";
+        case "wallet":
+            return "Wallet";
+    }
+}
+async function collectInteractive(options) {
+    const tokenName = options.name ??
+        (await input({
+            message: "What do you want to call your token?",
+            theme: output.bankrTheme,
+            required: true,
+        }));
+    const tokenSymbol = options.symbol ??
+        (await input({
+            message: "Token symbol (press Enter to auto-generate from name):",
+            theme: output.bankrTheme,
+        }));
+    const imageUrl = options.image ??
+        (await input({
+            message: "Image URL for your token (press Enter to skip):",
+            theme: output.bankrTheme,
+        }));
+    const tweetUrl = options.tweet ??
+        (await input({
+            message: "Associate with a tweet? Paste URL (press Enter to skip):",
+            theme: output.bankrTheme,
+        }));
+    const websiteUrl = options.website ??
+        (await input({
+            message: "Project website URL (press Enter to skip):",
+            theme: output.bankrTheme,
+        }));
+    let feeRecipient = options.fee ??
+        (await input({
+            message: "Direct fees to someone? Enter username, ENS, or address (press Enter to skip):",
+            theme: output.bankrTheme,
+        }));
+    let feeRecipientType = parseFeeType(options.feeType);
+    if (feeRecipient && !options.feeType) {
+        feeRecipientType = await select({
+            message: "What type of identifier is this?",
+            choices: [
+                { name: "X (Twitter)", value: "x" },
+                { name: "Farcaster", value: "farcaster" },
+                { name: "ENS", value: "ens" },
+                { name: "Wallet address", value: "wallet" },
+            ],
+            theme: output.bankrTheme,
+        });
+    }
+    if (!feeRecipient) {
+        feeRecipient = "";
+    }
+    return {
+        tokenName: tokenName.trim(),
+        tokenSymbol: tokenSymbol.trim(),
+        imageUrl: imageUrl.trim(),
+        tweetUrl: tweetUrl.trim(),
+        websiteUrl: websiteUrl.trim(),
+        feeRecipient: feeRecipient.trim(),
+        feeRecipientType,
+    };
+}
+export async function launchCommand(options) {
+    requireApiKey();
+    // Collect token details
+    const state = await collectInteractive(options);
+    if (!state.tokenName) {
+        output.error("Token name is required.");
+        process.exit(1);
+    }
+    // Display summary
+    console.log();
+    output.brandBold("  Token launch summary");
+    console.log();
+    output.keyValue("Name", state.tokenName);
+    output.keyValue("Symbol", state.tokenSymbol || "(auto)");
+    output.keyValue("Image", state.imageUrl || "(none)");
+    output.keyValue("Tweet", state.tweetUrl || "(none)");
+    output.keyValue("Website", state.websiteUrl || "(none)");
+    output.keyValue("Fee recipient", state.feeRecipient
+        ? `${state.feeRecipient} (${feeTypeLabel(state.feeRecipientType)})`
+        : "(self)");
+    output.keyValue("Chain", "Base");
+    if (options.simulate) {
+        output.keyValue("Mode", "Simulation (dry run)");
+    }
+    console.log();
+    // Confirm unless --yes
+    if (!options.yes) {
+        const proceed = await confirm({
+            message: options.simulate
+                ? "Simulate this token launch?"
+                : "Launch this token?",
+            default: true,
+            theme: output.bankrTheme,
+        });
+        if (!proceed) {
+            output.dim("Launch cancelled.");
+            return;
+        }
+    }
+    // Deploy directly via REST endpoint (no LLM agent)
+    const spin = output.spinner(options.simulate ? "Simulating token deploy..." : "Deploying your token...");
+    const startTime = Date.now();
+    try {
+        const result = await deployToken({
+            tokenName: state.tokenName,
+            tokenSymbol: state.tokenSymbol || undefined,
+            image: state.imageUrl || undefined,
+            tweetUrl: state.tweetUrl || undefined,
+            websiteUrl: state.websiteUrl || undefined,
+            feeRecipient: state.feeRecipient
+                ? { type: state.feeRecipientType, value: state.feeRecipient }
+                : undefined,
+            simulateOnly: options.simulate,
+        });
+        const elapsed = output.formatDuration(Date.now() - startTime);
+        spin.succeed(result.simulated
+            ? `Simulation complete in ${elapsed}`
+            : `Token deployed in ${elapsed}`);
+        emitCESP("task.complete");
+        console.log();
+        output.keyValue("Token Address", result.tokenAddress);
+        output.keyValue("Pool ID", result.poolId);
+        if (result.txHash) {
+            output.keyValue("Transaction", result.txHash);
+        }
+        output.keyValue("Chain", result.chain);
+        if (result.feeDistribution) {
+            console.log();
+            output.brandBold("  Fee distribution");
+            console.log();
+            for (const [role, info] of Object.entries(result.feeDistribution)) {
+                const pct = (info.bps / 100).toFixed(1);
+                const label = role === "alt"
+                    ? "Ecosystem"
+                    : role.charAt(0).toUpperCase() + role.slice(1);
+                output.keyValue(`  ${label} (${pct}%)`, info.address);
+            }
+        }
+        console.log();
+        output.dim(`View token: https://bankr.bot/launches/${result.tokenAddress}`);
+    }
+    catch (err) {
+        spin.fail("Token launch failed");
+        emitCESP("task.error");
+        output.error(err.message);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=launch.js.map

package/dist/commands/llm.d.ts

@@ -1,5 +1,16 @@
 export declare function modelsCommand(): Promise<void>;
 export declare function creditsCommand(): Promise<void>;
+export declare function creditsAddCommand(amount: string, opts: {
+    token?: string;
+    yes?: boolean;
+}): Promise<void>;
+export declare function creditsAutoCommand(opts: {
+    enable?: boolean;
+    disable?: boolean;
+    amount?: string;
+    threshold?: string;
+    tokens?: string;
+}): Promise<void>;
 export declare function setupOpenclawCommand(opts: {
     install?: boolean;
 }): Promise<void>;

package/dist/commands/llm.js

@@ -2,8 +2,11 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
 import { spawn } from "child_process";
-import { getLlmKey, getLlmUrl } from "../lib/config.js";
+import { CLI_USER_AGENT, getApiUrl, getLlmKey, getLlmUrl, requireApiKey, } from "../lib/config.js";
+import { getBalances } from "../lib/api.js";
 import * as output from "../lib/output.js";
+import { bankrTheme } from "../lib/output.js";
+const ERR_LLM_NOT_ENABLED = "LLM Gateway not enabled on this API key. Enable at bankr.bot/api";
 /**
  * Fallback model catalog — used when the gateway is unreachable or unauthenticated.
  * resolveModels() fetches live data from GET /v1/models; this list is the offline safety net.
@@ -22,6 +25,12 @@ const GATEWAY_MODELS = [
         owned_by: "anthropic",
         cost: { input: 15.0, output: 75.0, cacheRead: 1.5, cacheWrite: 18.75 },
     },
+    {
+        id: "claude-sonnet-4.6",
+        name: "Claude Sonnet 4.6",
+        owned_by: "anthropic",
+        cost: { input: 3.0, output: 15.0, cacheRead: 0.3, cacheWrite: 3.75 },
+    },
     {
         id: "claude-sonnet-4.5",
         name: "Claude Sonnet 4.5",
@@ -105,7 +114,7 @@ async function resolveModels() {
         return { models: GATEWAY_MODELS, live: false };
     try {
         const res = await fetch(`${getLlmUrl()}/v1/models`, {
-            headers: { "X-API-Key": llmKey },
+            headers: { "X-API-Key": llmKey, "User-Agent": CLI_USER_AGENT },
             signal: AbortSignal.timeout(5000),
         });
         if (!res.ok)
@@ -195,7 +204,7 @@ export async function creditsCommand() {
     const spin = output.spinner("Fetching credit balance…");
     try {
         const res = await fetch(`${llmUrl}/v1/credits`, {
-            headers: { "X-API-Key": llmKey },
+            headers: { "X-API-Key": llmKey, "User-Agent": CLI_USER_AGENT },
             signal: AbortSignal.timeout(10000),
         });
         spin.stop();
@@ -228,6 +237,313 @@ export async function creditsCommand() {
         process.exit(1);
     }
 }
+/* ─────────────────────── bankr llm credits add ──────────────────────────── */
+export async function creditsAddCommand(amount, opts) {
+    const apiKey = requireApiKey();
+    const apiUrl = getApiUrl();
+    const llmKey = getLlmKey();
+    const llmUrl = getLlmUrl();
+    // Validate amount
+    const amountUsd = Number(amount);
+    if (Number.isNaN(amountUsd) || amountUsd < 1 || amountUsd > 1000) {
+        output.error("Amount must be between $1 and $1,000");
+        process.exit(1);
+    }
+    // Fetch current balance for display (skip when --yes since user won't see it)
+    let currentBalance = "unknown";
+    if (llmKey && !opts.yes) {
+        const balSpin = output.spinner("Fetching balance…");
+        try {
+            const balRes = await fetch(`${llmUrl}/v1/credits`, {
+                headers: { "X-API-Key": llmKey, "User-Agent": CLI_USER_AGENT },
+                signal: AbortSignal.timeout(10000),
+            });
+            balSpin.stop();
+            if (balRes.ok) {
+                const bal = (await balRes.json());
+                currentBalance = `$${bal.balanceUsd.toFixed(2)}`;
+            }
+            else if (balRes.status === 402) {
+                currentBalance = "$0.00";
+            }
+        }
+        catch (err) {
+            balSpin.stop();
+            // Non-fatal — proceed without balance display
+            output.dim(`  (Could not fetch balance: ${err.message})`);
+        }
+    }
+    // Show confirmation
+    console.log();
+    output.label("Add Credits", `$${amountUsd.toFixed(2)}`);
+    output.keyValue("Source token", opts.token ?? "USDC (default)");
+    output.keyValue("Current balance", currentBalance);
+    console.log();
+    if (!opts.yes) {
+        const { confirm } = await import("@inquirer/prompts");
+        const proceed = await confirm({
+            message: "Proceed?",
+            default: true,
+            theme: bankrTheme,
+        });
+        if (!proceed) {
+            output.dim("Cancelled.");
+            return;
+        }
+    }
+    const spin = output.spinner("Adding credits…");
+    try {
+        const body = { amountUsd };
+        if (opts.token) {
+            body.sourceToken = opts.token;
+        }
+        const res = await fetch(`${apiUrl}/llm/credits/topup`, {
+            method: "POST",
+            headers: {
+                "X-API-Key": apiKey,
+                "Content-Type": "application/json",
+                "User-Agent": CLI_USER_AGENT,
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(60000),
+        });
+        spin.stop();
+        if (res.status === 402) {
+            output.error("Insufficient wallet balance. Add funds to your wallet first.");
+            process.exit(1);
+        }
+        if (res.status === 403) {
+            output.error(ERR_LLM_NOT_ENABLED);
+            process.exit(1);
+        }
+        if (res.status === 502) {
+            output.error("Token swap failed. Try USDC or a different token.");
+            process.exit(1);
+        }
+        if (!res.ok) {
+            const errBody = (await res.json().catch(() => ({})));
+            output.error(errBody.error ?? `Failed to add credits (HTTP ${res.status})`);
+            process.exit(1);
+        }
+        const result = (await res.json());
+        console.log();
+        output.success(`Added $${result.creditsGranted.toFixed(2)} credits`);
+        output.label("New Balance", `$${result.newBalance.toFixed(2)}`);
+        if (result.txHash) {
+            output.keyValue("Transaction", `https://basescan.org/tx/${result.txHash}`);
+        }
+    }
+    catch (err) {
+        spin.stop();
+        output.error(`Failed to add credits: ${err.message}`);
+        process.exit(1);
+    }
+}
+function formatTimeAgo(dateStr) {
+    if (!dateStr)
+        return "never";
+    const diff = Date.now() - new Date(dateStr).getTime();
+    const mins = Math.floor(diff / 60000);
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+function displayAutoTopUpConfig(config) {
+    output.keyValue("Status", config.enabled ? "Enabled" : "Disabled");
+    output.keyValue("Amount", `$${config.amountUsd.toFixed(2)}`);
+    output.keyValue("Threshold", `$${config.thresholdUsd.toFixed(2)}`);
+    output.keyValue("Tokens", config.tokens.length > 0
+        ? config.tokens.map((t) => t.symbol).join(" → ")
+        : "none configured");
+}
+export async function creditsAutoCommand(opts) {
+    const apiKey = requireApiKey();
+    const apiUrl = getApiUrl();
+    const isUpdate = opts.enable || opts.disable || opts.amount || opts.threshold || opts.tokens;
+    if (!isUpdate) {
+        // GET current config
+        const spin = output.spinner("Fetching auto top-up config…");
+        try {
+            const res = await fetch(`${apiUrl}/llm/credits/auto-topup`, {
+                headers: {
+                    "X-API-Key": apiKey,
+                    "User-Agent": CLI_USER_AGENT,
+                },
+                signal: AbortSignal.timeout(10000),
+            });
+            spin.stop();
+            if (res.status === 403) {
+                output.error(ERR_LLM_NOT_ENABLED);
+                process.exit(1);
+            }
+            if (!res.ok) {
+                output.error(`Failed to fetch config (HTTP ${res.status})`);
+                process.exit(1);
+            }
+            const { config } = (await res.json());
+            output.brandBold("Bankr LLM Gateway — Auto Top-Up");
+            console.log();
+            displayAutoTopUpConfig(config);
+            output.keyValue("Last top-up", formatTimeAgo(config.lastTopUpAt));
+            if (config.lastError) {
+                output.keyValue("Last error", config.lastError.message);
+            }
+            console.log();
+            output.dim("  Update: bankr llm credits auto --amount 25 --tokens USDC");
+        }
+        catch (err) {
+            spin.stop();
+            output.error(`Failed to fetch config: ${err.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    // POST update config
+    if (opts.enable && opts.disable) {
+        output.error("Cannot use --enable and --disable together");
+        process.exit(1);
+    }
+    const body = {};
+    if (opts.disable) {
+        body.enabled = false;
+    }
+    else if (opts.enable) {
+        body.enabled = true;
+    }
+    else if (opts.amount || opts.threshold || opts.tokens) {
+        // Setting config values implicitly enables
+        body.enabled = true;
+    }
+    if (opts.amount) {
+        const amt = Number(opts.amount);
+        if (Number.isNaN(amt) || amt < 1 || amt > 1000) {
+            output.error("Amount must be between $1 and $1,000");
+            process.exit(1);
+        }
+        body.amountUsd = amt;
+    }
+    if (opts.threshold) {
+        const thr = Number(opts.threshold);
+        if (Number.isNaN(thr) || thr < 1 || thr > 500) {
+            output.error("Threshold must be between $1 and $500");
+            process.exit(1);
+        }
+        body.thresholdUsd = thr;
+    }
+    const missing = [];
+    if (opts.tokens) {
+        // Accepts symbols (USDC) or addresses (0x...), comma-separated
+        const inputs = opts.tokens
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+        if (inputs.length === 0 || inputs.length > 3) {
+            output.error("Provide 1-3 comma-separated token symbols or addresses");
+            process.exit(1);
+        }
+        const resolved = [];
+        // Fetch balances to resolve both symbols and addresses
+        const spin = output.spinner("Resolving tokens…");
+        let baseTokens = [];
+        let hasNativeEth = false;
+        try {
+            const balData = await getBalances(["base"]);
+            const baseChain = balData.balances.base;
+            baseTokens = baseChain?.tokenBalances ?? [];
+            hasNativeEth = !!baseChain && parseFloat(baseChain.nativeBalance) > 0;
+        }
+        catch {
+            output.warn("Could not fetch balances for token resolution");
+        }
+        spin.stop();
+        for (const input of inputs) {
+            const isAddress = input.startsWith("0x");
+            const sym = isAddress ? null : input.toUpperCase();
+            // Native ETH
+            if (sym === "ETH" && hasNativeEth) {
+                resolved.push({
+                    address: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+                    chain: "base",
+                    symbol: "ETH",
+                    name: "Ethereum",
+                    decimals: 18,
+                });
+                continue;
+            }
+            const tb = baseTokens.find((t) => isAddress
+                ? t.token.baseToken.address.toLowerCase() === input.toLowerCase()
+                : t.token.baseToken.symbol.toUpperCase() === sym);
+            if (tb) {
+                resolved.push({
+                    address: tb.token.baseToken.address,
+                    chain: "base",
+                    symbol: tb.token.baseToken.symbol,
+                    name: tb.token.baseToken.name,
+                    decimals: tb.token.baseToken.decimals,
+                    imageUrl: tb.token.baseToken.imgUrl,
+                });
+            }
+            else {
+                missing.push(input);
+            }
+        }
+        if (resolved.length === 0) {
+            output.error("No valid tokens resolved. Check your token symbols.");
+            process.exit(1);
+        }
+        body.tokens = resolved;
+    }
+    // Collect warnings to show after success output
+    const warnings = [];
+    if (missing.length > 0) {
+        warnings.push(`Token(s) not found in wallet: ${missing.join(", ")} — skipped`);
+    }
+    const spin = output.spinner("Updating auto top-up…");
+    try {
+        const res = await fetch(`${apiUrl}/llm/credits/auto-topup`, {
+            method: "POST",
+            headers: {
+                "X-API-Key": apiKey,
+                "Content-Type": "application/json",
+                "User-Agent": CLI_USER_AGENT,
+            },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(10000),
+        });
+        spin.stop();
+        if (res.status === 403) {
+            output.error(ERR_LLM_NOT_ENABLED);
+            process.exit(1);
+        }
+        if (!res.ok) {
+            const errBody = (await res.json().catch(() => ({})));
+            output.error(errBody.error ?? `Failed to update config (HTTP ${res.status})`);
+            process.exit(1);
+        }
+        output.success(opts.disable ? "Auto top-up disabled" : "Auto top-up settings updated");
+        // Show config from POST response (avoids extra GET round-trip)
+        const resBody = (await res.json());
+        if (resBody.config) {
+            console.log();
+            displayAutoTopUpConfig(resBody.config);
+        }
+        if (warnings.length > 0) {
+            console.log();
+            for (const w of warnings) {
+                output.warn(w);
+            }
+        }
+    }
+    catch (err) {
+        spin.stop();
+        output.error(`Failed to update config: ${err.message}`);
+        process.exit(1);
+    }
+}
 /* ──────────────────────── bankr llm setup openclaw ────────────────────────── */
 export async function setupOpenclawCommand(opts) {
     const llmKey = getLlmKey();

package/dist/commands/login.d.ts

@@ -1,7 +1,16 @@
 export declare function loginCommand(opts: {
     apiUrl?: string;
     apiKey?: string;
+    email?: string;
+    code?: string;
+    acceptTerms?: boolean;
+    keyName?: string;
+    readWrite?: boolean;
+    llm?: boolean;
     llmKey?: string;
     url?: boolean;
+    siwe?: boolean;
+    privateKey?: string;
+    partnerKey?: string;
 }): Promise<void>;
 //# sourceMappingURL=login.d.ts.map