@bankr/cli 0.2.0 → 0.2.3

package/dist/cli.js

@@ -22,8 +22,10 @@ import { submitCommand, submitJsonCommand } from "./commands/submit.js";
 import { updateCommand } from "./commands/update.js";
 import { whoamiCommand } from "./commands/whoami.js";
 import { tokensSearchCommand, tokensInfoCommand } from "./commands/tokens.js";
+import { x402InitCommand, x402AddCommand, x402ConfigureCommand, x402DeployCommand, x402ListCommand, x402PauseResumeCommand, x402DeleteCommand, x402RevenueCommand, x402EnvSetCommand, x402EnvListCommand, x402EnvUnsetCommand, x402SearchCommand, } from "./commands/x402.js";
 import { profileViewCommand, profileCreateCommand, profileUpdateCommand, profileDeleteCommand, profileAddUpdateCommand, } from "./commands/profile.js";
 import * as output from "./lib/output.js";
+import { checkForUpdate } from "./lib/updateCheck.js";
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 /**
  * Read prompt text from stdin (piped) or interactively.
@@ -712,6 +714,66 @@ program
     .action(async (opts) => {
     await updateCommand({ check: opts.check });
 });
+// ── x402 Endpoint Hosting ─────────────────────────────────────────────
+const x402Cmd = program
+    .command("x402")
+    .description("Deploy and manage x402 paid API endpoints");
+x402Cmd
+    .command("init")
+    .description("Scaffold x402/ folder and bankr.x402.json config")
+    .action(x402InitCommand);
+x402Cmd
+    .command("add <name>")
+    .description("Add a new x402 service handler")
+    .action(x402AddCommand);
+x402Cmd
+    .command("configure <name>")
+    .description("Interactively configure pricing and description")
+    .action(x402ConfigureCommand);
+x402Cmd
+    .command("deploy [name]")
+    .description("Bundle and deploy services to Bankr")
+    .action(x402DeployCommand);
+x402Cmd
+    .command("list")
+    .description("List your deployed x402 endpoints")
+    .action(x402ListCommand);
+x402Cmd
+    .command("pause <name>")
+    .description("Pause a deployed endpoint")
+    .action(async (name) => x402PauseResumeCommand(name, "pause"));
+x402Cmd
+    .command("resume <name>")
+    .description("Resume a paused endpoint")
+    .action(async (name) => x402PauseResumeCommand(name, "resume"));
+x402Cmd
+    .command("delete <name>")
+    .description("Delete a deployed endpoint")
+    .action(x402DeleteCommand);
+x402Cmd
+    .command("revenue [name]")
+    .description("View endpoint earnings breakdown")
+    .action(x402RevenueCommand);
+const x402EnvCmd = x402Cmd
+    .command("env")
+    .description("Manage encrypted environment variables");
+x402EnvCmd
+    .command("set <keyValue>")
+    .description("Set an env var (KEY=VALUE)")
+    .action(x402EnvSetCommand);
+x402EnvCmd
+    .command("list")
+    .description("List env var names")
+    .action(x402EnvListCommand);
+x402EnvCmd
+    .command("unset <key>")
+    .description("Remove an env var")
+    .action(x402EnvUnsetCommand);
+x402Cmd
+    .command("search [query...]")
+    .description("Search the x402 service marketplace (no auth required)")
+    .option("--raw", "Output raw JSON (unformatted)")
+    .action(async (query, opts) => x402SearchCommand(query, { raw: opts.raw }));
 // Default: treat unrecognized arguments as a prompt
 program
     .arguments("[text...]")
@@ -737,6 +799,7 @@ async function main() {
         output.error(err.message);
         process.exit(1);
     }
+    await checkForUpdate(pkg.version);
 }
 main();
 //# sourceMappingURL=cli.js.map

package/dist/commands/llm.js

@@ -79,15 +79,6 @@ const GATEWAY_MODELS = [
         input: IMAGE_INPUT,
         cost: { input: 0.25, output: 1.5, cacheRead: 0.025, cacheWrite: 0.08333 },
     },
-    {
-        id: "gemini-3-pro",
-        name: "Gemini 3 Pro",
-        owned_by: "google",
-        contextWindow: 1048576,
-        maxTokens: 65536,
-        input: IMAGE_INPUT,
-        cost: { input: 2.0, output: 12.0, cacheRead: 0.2, cacheWrite: 0.375 },
-    },
     {
         id: "gemini-3-flash",
         name: "Gemini 3 Flash",
@@ -238,20 +229,29 @@ const GATEWAY_MODELS = [
         id: "minimax-m2.5",
         name: "MiniMax M2.5",
         owned_by: "minimax",
-        contextWindow: 196608,
+        contextWindow: 204800,
         maxTokens: 196608,
         input: TEXT_INPUT,
-        cost: { input: 0.27, output: 0.95, cacheRead: 0.03, cacheWrite: 0 },
+        cost: { input: 0.3, output: 1.2, cacheRead: 0.03, cacheWrite: 0 },
     },
     {
         id: "minimax-m2.7",
         name: "MiniMax M2.7",
         owned_by: "minimax",
         contextWindow: 204800,
-        maxTokens: 131072,
+        maxTokens: 196608,
         input: TEXT_INPUT,
         cost: { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0 },
     },
+    {
+        id: "minimax-m2.7-highspeed",
+        name: "MiniMax M2.7 Highspeed",
+        owned_by: "minimax",
+        contextWindow: 204800,
+        maxTokens: 196608,
+        input: TEXT_INPUT,
+        cost: { input: 0.6, output: 2.4, cacheRead: 0.06, cacheWrite: 0 },
+    },
     {
         id: "glm-5",
         name: "GLM-5",
@@ -261,6 +261,15 @@ const GATEWAY_MODELS = [
         input: TEXT_INPUT,
         cost: { input: 0.72, output: 2.3, cacheRead: 0, cacheWrite: 0 },
     },
+    {
+        id: "glm-5-turbo",
+        name: "GLM-5 Turbo",
+        owned_by: "z-ai",
+        contextWindow: 202752,
+        maxTokens: 131072,
+        input: TEXT_INPUT,
+        cost: { input: 1.2, output: 4.0, cacheRead: 0.24, cacheWrite: 0 },
+    },
 ];
 /** Fetch live model list from the gateway; falls back to hardcoded catalog. */
 async function resolveModels() {
@@ -715,11 +724,12 @@ export async function setupOpenclawCommand(opts) {
     const llmKey = getLlmKey();
     const llmUrl = getLlmUrl();
     const { models } = await resolveModels();
+    const activeModels = models.filter((m) => !m.deprecation);
     const providerConfig = {
         baseUrl: llmUrl,
         apiKey: llmKey ?? "${BANKR_API_KEY}",
         api: "openai-completions",
-        models: models.map((m) => ({
+        models: activeModels.map((m) => ({
             id: m.id,
             name: m.name,
             ...(m.owned_by === "anthropic" ? { api: "anthropic-messages" } : {}),
@@ -753,8 +763,9 @@ export async function setupOpenCodeCommand(opts) {
     const llmKey = getLlmKey();
     const llmUrl = getLlmUrl();
     const { models } = await resolveModels();
+    const activeModels = models.filter((m) => !m.deprecation);
     const modelsObj = {};
-    for (const m of models) {
+    for (const m of activeModels) {
         modelsObj[m.id] = { name: m.name };
     }
     const bankrProvider = {
@@ -796,9 +807,10 @@ export async function setupCursorCommand() {
     const llmUrl = getLlmUrl();
     const token = llmKey ?? "<your-bankr-api-key>";
     const { models } = await resolveModels();
+    const activeModels = models.filter((m) => !m.deprecation);
     // Pick one model per provider as recommended examples
-    const recommendedIds = ["claude-opus-4.6", "gemini-3-pro", "gpt-5.2"];
-    const recommended = recommendedIds.filter((id) => models.some((m) => m.id === id));
+    const recommendedIds = ["claude-opus-4.6", "gemini-3.1-pro", "gpt-5.2"];
+    const recommended = recommendedIds.filter((id) => activeModels.some((m) => m.id === id));
     output.brandBold("Cursor — Bankr LLM Gateway");
     console.log();
     output.info("In Cursor, go to Settings > Models and configure:");

package/dist/commands/x402.d.ts

@@ -0,0 +1,65 @@
+/**
+ * CLI commands for x402 endpoint hosting.
+ *
+ * bankr x402 init                     — Scaffold x402/ folder + bankr.x402.json
+ * bankr x402 add <name>               — Add a new service
+ * bankr x402 configure <name>         — Interactive pricing/description setup
+ * bankr x402 deploy [name]            — Deploy all or a single service
+ * bankr x402 list                     — List deployed services
+ * bankr x402 logs <name>              — View request logs (future)
+ * bankr x402 pause <name>             — Pause a service
+ * bankr x402 resume <name>            — Resume a service
+ * bankr x402 delete <name>            — Delete a service
+ * bankr x402 revenue [name]           — View earnings
+ * bankr x402 env set KEY=VALUE        — Set encrypted env var
+ * bankr x402 env list                 — List env var names
+ * bankr x402 env unset KEY            — Remove env var
+ */
+/**
+ * bankr x402 init — Scaffold x402/ folder + bankr.x402.json
+ */
+export declare function x402InitCommand(): Promise<void>;
+export declare function x402AddCommand(name: string): Promise<void>;
+/**
+ * bankr x402 configure <name> — Interactive pricing/description setup
+ */
+export declare function x402ConfigureCommand(name: string): Promise<void>;
+/**
+ * bankr x402 deploy [name] — Deploy services
+ *
+ * This bundles the handler(s) with Bun and uploads via the Bankr API.
+ * If no name is provided, deploys all services in x402/.
+ */
+export declare function x402DeployCommand(name?: string): Promise<void>;
+/**
+ * bankr x402 list — List deployed services
+ */
+export declare function x402ListCommand(): Promise<void>;
+/**
+ * bankr x402 pause/resume <name>
+ */
+export declare function x402PauseResumeCommand(name: string, action: "pause" | "resume"): Promise<void>;
+/**
+ * bankr x402 delete <name>
+ */
+export declare function x402DeleteCommand(name: string): Promise<void>;
+/**
+ * bankr x402 revenue [name]
+ */
+export declare function x402RevenueCommand(name?: string): Promise<void>;
+/**
+ * bankr x402 env set KEY=VALUE
+ */
+export declare function x402EnvSetCommand(keyValue: string): Promise<void>;
+/**
+ * bankr x402 env list
+ */
+export declare function x402EnvListCommand(): Promise<void>;
+/**
+ * bankr x402 env unset KEY
+ */
+export declare function x402EnvUnsetCommand(key: string): Promise<void>;
+export declare function x402SearchCommand(queryParts: string[], opts?: {
+    raw?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=x402.d.ts.map

package/dist/commands/x402.js

@@ -0,0 +1,761 @@
+/**
+ * CLI commands for x402 endpoint hosting.
+ *
+ * bankr x402 init                     — Scaffold x402/ folder + bankr.x402.json
+ * bankr x402 add <name>               — Add a new service
+ * bankr x402 configure <name>         — Interactive pricing/description setup
+ * bankr x402 deploy [name]            — Deploy all or a single service
+ * bankr x402 list                     — List deployed services
+ * bankr x402 logs <name>              — View request logs (future)
+ * bankr x402 pause <name>             — Pause a service
+ * bankr x402 resume <name>            — Resume a service
+ * bankr x402 delete <name>            — Delete a service
+ * bankr x402 revenue [name]           — View earnings
+ * bankr x402 env set KEY=VALUE        — Set encrypted env var
+ * bankr x402 env list                 — List env var names
+ * bankr x402 env unset KEY            — Remove env var
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { input, select, confirm } from "@inquirer/prompts";
+import * as output from "../lib/output.js";
+import { getApiUrl, requireApiKey, readConfig, CLI_USER_AGENT, } from "../lib/config.js";
+// ── Config file helpers ─────────────────────────────────────────────────
+const CONFIG_FILENAME = "bankr.x402.json";
+function findProjectRoot() {
+    return process.cwd();
+}
+function loadConfigFile(projectRoot) {
+    const candidates = [
+        join(projectRoot, CONFIG_FILENAME),
+        join(projectRoot, "x402", CONFIG_FILENAME),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p)) {
+            try {
+                return JSON.parse(readFileSync(p, "utf-8"));
+            }
+            catch {
+                output.error(`Failed to parse ${p}. Check that it is valid JSON.`);
+                process.exit(1);
+            }
+        }
+    }
+    return null;
+}
+function saveConfigFile(projectRoot, config) {
+    const configPath = join(projectRoot, CONFIG_FILENAME);
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+// ── API helpers ─────────────────────────────────────────────────────────
+function authHeaders() {
+    const headers = {
+        "X-API-Key": requireApiKey(),
+        "Content-Type": "application/json",
+        "User-Agent": CLI_USER_AGENT,
+    };
+    const config = readConfig();
+    if (config.partnerKey) {
+        headers["X-Partner-Key"] = config.partnerKey;
+    }
+    return headers;
+}
+async function handleResponse(res) {
+    if (!res.ok) {
+        const body = (await res
+            .json()
+            .catch(() => ({ message: res.statusText })));
+        const msg = body.message || body.error || res.statusText;
+        throw new Error(`API error (${res.status}): ${msg}`);
+    }
+    return res.json();
+}
+// ── Default handler template ────────────────────────────────────────────
+const HANDLER_TEMPLATE = `/**
+ * x402 service handler.
+ *
+ * Receives a standard Web Request, returns a standard Web Response.
+ * Bankr wraps the x402 payment layer around this — you just write the logic.
+ *
+ * Environment variables are available via process.env.
+ */
+export default async function handler(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+
+  return Response.json({
+    message: "Hello from SERVICE_NAME!",
+    timestamp: new Date().toISOString(),
+  });
+}
+`;
+// ── Commands ────────────────────────────────────────────────────────────
+/**
+ * bankr x402 init — Scaffold x402/ folder + bankr.x402.json
+ */
+export async function x402InitCommand() {
+    const root = findProjectRoot();
+    const x402Dir = join(root, "x402");
+    if (existsSync(x402Dir)) {
+        output.warn("x402/ directory already exists");
+        const overwrite = await confirm({
+            message: "Re-initialize config?",
+            default: false,
+            theme: output.bankrTheme,
+        });
+        if (!overwrite)
+            return;
+    }
+    else {
+        mkdirSync(x402Dir, { recursive: true });
+        output.success(`Created x402/ directory`);
+    }
+    const existing = loadConfigFile(root);
+    if (!existing) {
+        const config = {
+            network: "base",
+            currency: "USDC",
+            services: {},
+        };
+        saveConfigFile(root, config);
+        output.success(`Created ${CONFIG_FILENAME}`);
+    }
+    else {
+        output.info(`${CONFIG_FILENAME} already exists, keeping it`);
+    }
+    output.info("Next: run 'bankr x402 add <name>' to create your first service");
+}
+/**
+ * bankr x402 add <name> — Add a new service with handler scaffold
+ */
+const MAX_SERVICE_NAME_LENGTH = 47; // bx4- (4) + hash (12) + - (1) = 17 overhead; 64 - 17 = 47
+const SERVICE_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function validateServiceName(name) {
+    if (!SERVICE_NAME_PATTERN.test(name)) {
+        return `Invalid service name "${name}". Use only letters, numbers, hyphens, and underscores.`;
+    }
+    if (name.length > MAX_SERVICE_NAME_LENGTH) {
+        return `Service name "${name}" is too long (${name.length} chars). Maximum is ${MAX_SERVICE_NAME_LENGTH} characters.`;
+    }
+    return null;
+}
+export async function x402AddCommand(name) {
+    const nameError = validateServiceName(name);
+    if (nameError) {
+        output.error(nameError);
+        process.exit(1);
+    }
+    const root = findProjectRoot();
+    const x402Dir = join(root, "x402");
+    if (!existsSync(x402Dir)) {
+        output.error("No x402/ directory found. Run 'bankr x402 init' first.");
+        process.exit(1);
+    }
+    const serviceDir = join(x402Dir, name);
+    if (existsSync(serviceDir)) {
+        output.error(`Service "${name}" already exists at x402/${name}/`);
+        process.exit(1);
+    }
+    // Ask for method
+    const method = await select({
+        message: "HTTP method:",
+        choices: [
+            { name: "GET — query parameters in URL", value: "GET" },
+            { name: "POST — JSON body", value: "POST" },
+            { name: "Any — accept all methods", value: "*" },
+        ],
+        default: "GET",
+        theme: output.bankrTheme,
+    });
+    // Create service directory and handler
+    mkdirSync(serviceDir, { recursive: true });
+    const isPost = method === "POST";
+    const handlerContent = isPost
+        ? `/**
+ * ${name} — x402 service handler (POST with JSON body).
+ */
+export default async function handler(req: Request): Promise<Response> {
+  if (req.method !== "POST") {
+    return Response.json({ error: "POST required" }, { status: 405 });
+  }
+
+  const body = await req.json();
+  // TODO: validate body fields
+
+  return Response.json({
+    message: "Hello from ${name}!",
+    received: body,
+    timestamp: new Date().toISOString(),
+  });
+}
+`
+        : `/**
+ * ${name} — x402 service handler.
+ */
+export default async function handler(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  // const myParam = url.searchParams.get("myParam") ?? "default";
+
+  return Response.json({
+    message: "Hello from ${name}!",
+    timestamp: new Date().toISOString(),
+  });
+}
+`;
+    writeFileSync(join(serviceDir, "index.ts"), handlerContent);
+    // Build JSON Schema scaffold
+    const schema = {
+        input: {
+            type: "object",
+            properties: {
+                [isPost ? "field" : "param"]: {
+                    type: "string",
+                    description: isPost ? "Example body field" : "Example query parameter",
+                },
+            },
+            required: [isPost ? "field" : "param"],
+        },
+        output: {
+            type: "object",
+            properties: {
+                result: { type: "string", description: "Result value" },
+            },
+        },
+    };
+    // Add to config
+    let config = loadConfigFile(root);
+    if (!config) {
+        config = { services: {} };
+    }
+    config.services[name] = {
+        price: "0.001",
+        description: `${name} service`,
+        methods: method === "*" ? undefined : [method],
+        schema,
+    };
+    saveConfigFile(root, config);
+    output.success(`Created x402/${name}/index.ts`);
+    output.info(`Default price: $0.001 USDC. Run 'bankr x402 configure ${name}' to customize.`);
+    output.info(`Edit the schema in bankr.x402.json to describe your ${isPost ? "body fields" : "query parameters"} for agent discovery.`);
+}
+/**
+ * bankr x402 configure <name> — Interactive pricing/description setup
+ */
+export async function x402ConfigureCommand(name) {
+    const root = findProjectRoot();
+    let config = loadConfigFile(root);
+    if (!config) {
+        config = { services: {} };
+    }
+    const existing = config.services[name] ?? { price: "0.001" };
+    const description = await input({
+        message: "Service description:",
+        default: existing.description ?? `${name} service`,
+        theme: output.bankrTheme,
+    });
+    const price = await input({
+        message: "Price per request (USD):",
+        default: existing.price ?? "0.001",
+        theme: output.bankrTheme,
+    });
+    const currency = "USDC";
+    const network = await select({
+        message: "Network:",
+        choices: [
+            { name: "Base", value: "base" },
+            { name: "Base Sepolia (testnet)", value: "base-sepolia" },
+        ],
+        default: existing.network ?? "base",
+        theme: output.bankrTheme,
+    });
+    const method = await select({
+        message: "HTTP method:",
+        choices: [
+            { name: "GET — query parameters in URL", value: "GET" },
+            { name: "POST — JSON body", value: "POST" },
+            { name: "Any — accept all methods", value: "*" },
+        ],
+        default: existing.methods?.[0] ?? "GET",
+        theme: output.bankrTheme,
+    });
+    config.services[name] = {
+        ...existing,
+        description,
+        price,
+        currency,
+        network,
+        methods: method === "*" ? undefined : [method],
+    };
+    saveConfigFile(root, config);
+    output.success(`Updated config for "${name}"`);
+}
+/**
+ * bankr x402 deploy [name] — Deploy services
+ *
+ * This bundles the handler(s) with Bun and uploads via the Bankr API.
+ * If no name is provided, deploys all services in x402/.
+ */
+export async function x402DeployCommand(name) {
+    const root = findProjectRoot();
+    const x402Dir = join(root, "x402");
+    if (!existsSync(x402Dir)) {
+        output.error("No x402/ directory found. Run 'bankr x402 init' first.");
+        process.exit(1);
+    }
+    // Load or bootstrap config
+    let config = loadConfigFile(root);
+    if (!config) {
+        config = { services: {} };
+    }
+    // Discover services
+    const { readdirSync, statSync } = await import("node:fs");
+    const entries = readdirSync(x402Dir);
+    const services = [];
+    for (const entry of entries) {
+        const entryPath = join(x402Dir, entry);
+        if (statSync(entryPath).isDirectory() &&
+            existsSync(join(entryPath, "index.ts"))) {
+            services.push(entry);
+        }
+    }
+    if (services.length === 0) {
+        output.error("No services found. Run 'bankr x402 add <name>' first.");
+        process.exit(1);
+    }
+    // Filter to single service if name provided
+    const toDeploy = name ? services.filter((s) => s === name) : services;
+    if (name && toDeploy.length === 0) {
+        output.error(`Service "${name}" not found in x402/`);
+        process.exit(1);
+    }
+    // Validate service names and ensure config entries
+    for (const svc of toDeploy) {
+        const nameError = validateServiceName(svc);
+        if (nameError) {
+            output.error(nameError);
+            process.exit(1);
+        }
+        if (!config.services[svc]) {
+            config.services[svc] = {
+                price: "0.001",
+                description: `${svc} service`,
+            };
+        }
+    }
+    const spin = output.spinner(`Deploying ${toDeploy.length} service(s)...`);
+    try {
+        // Read raw TypeScript source for each service.
+        // Bundling + security wrapping happens server-side in the builder Lambda.
+        const bundles = [];
+        for (const svc of toDeploy) {
+            const entrypoint = join(x402Dir, svc, "index.ts");
+            if (!existsSync(entrypoint)) {
+                spin.fail(`Missing handler: x402/${svc}/index.ts`);
+                process.exit(1);
+            }
+            const source = readFileSync(entrypoint, "utf-8");
+            bundles.push({ name: svc, source });
+        }
+        // Deploy via API (server-side build + deploy)
+        const res = await fetch(`${getApiUrl()}/x402/endpoints/deploy`, {
+            method: "POST",
+            headers: authHeaders(),
+            body: JSON.stringify({
+                config,
+                bundles: bundles.map((b) => ({
+                    name: b.name,
+                    source: b.source,
+                })),
+            }),
+        });
+        const result = await handleResponse(res);
+        spin.succeed(`Deployed ${result.deployments.length} service(s)`);
+        // Print results
+        console.log();
+        for (const dep of result.deployments) {
+            const svcConfig = config.services[dep.name];
+            output.label("  Service", dep.name);
+            output.label("  URL", dep.url);
+            output.label("  Price", `$${svcConfig?.price ?? "0.001"} ${svcConfig?.currency ?? "USDC"}/req`);
+            output.label("  Version", String(dep.version));
+            console.log();
+        }
+    }
+    catch (err) {
+        spin.fail("Deploy failed");
+        output.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+/**
+ * bankr x402 list — List deployed services
+ */
+export async function x402ListCommand() {
+    const spin = output.spinner("Fetching endpoints...");
+    try {
+        const res = await fetch(`${getApiUrl()}/x402/endpoints`, {
+            headers: authHeaders(),
+        });
+        const result = await handleResponse(res);
+        spin.stop();
+        if (result.endpoints.length === 0) {
+            output.info("No deployed endpoints. Run 'bankr x402 deploy' to get started.");
+            return;
+        }
+        for (const ep of result.endpoints) {
+            const route = ep.routes[0];
+            const status = ep.status === "active"
+                ? output.fmt.success("active")
+                : output.fmt.warn(ep.status);
+            console.log(`  ${output.fmt.brand(ep.name)} ${status}  v${ep.version}  $${route?.price ?? "?"} ${route?.currency ?? "USDC"}  ${ep.totalRequests} reqs  $${ep.totalRevenueUsd} earned`);
+            output.dim(`    ${ep.description}`);
+        }
+    }
+    catch (err) {
+        spin.fail("Failed to list endpoints");
+        output.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+/**
+ * bankr x402 pause/resume <name>
+ */
+export async function x402PauseResumeCommand(name, action) {
+    const status = action === "pause" ? "paused" : "active";
+    const spin = output.spinner(`${action === "pause" ? "Pausing" : "Resuming"} ${name}...`);
+    try {
+        const res = await fetch(`${getApiUrl()}/x402/endpoints/${name}`, {
+            method: "PATCH",
+            headers: authHeaders(),
+            body: JSON.stringify({ status }),
+        });
+        await handleResponse(res);
+        spin.succeed(`${name} ${action === "pause" ? "paused" : "resumed"}`);
+    }
+    catch (err) {
+        spin.fail(`Failed to ${action} ${name}`);
+        output.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+/**
+ * bankr x402 delete <name>
+ */
+export async function x402DeleteCommand(name) {
+    const confirmed = await confirm({
+        message: `Delete endpoint "${name}"? This cannot be undone.`,
+        default: false,
+        theme: output.bankrTheme,
+    });
+    if (!confirmed)
+        return;
+    const spin = output.spinner(`Deleting ${name}...`);
+    try {
+        const res = await fetch(`${getApiUrl()}/x402/endpoints/${name}`, {
+            method: "DELETE",
+            headers: authHeaders(),
+        });
+        await handleResponse(res);
+        spin.succeed(`${name} deleted`);
+    }
+    catch (err) {
+        spin.fail(`Failed to delete ${name}`);
+        output.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+/**
+ * bankr x402 revenue [name]
+ */
+export async function x402RevenueCommand(name) {
+    if (!name) {
+        // Show all endpoints revenue summary
+        await x402ListCommand();
+        return;
+    }
+    const spin = output.spinner(`Fetching revenue for ${name}...`);
+    try {
+        const res = await fetch(`${getApiUrl()}/x402/endpoints/revenue/${name}`, {
+            headers: authHeaders(),
+        });
+        const result = await handleResponse(res);
+        spin.stop();
+        console.log(`\n  Revenue for ${output.fmt.brand(name)}\n`);
+        for (const [period, data] of Object.entries(result.revenue)) {
+            const label = period === "last7d"
+                ? "Last 7 days"
+                : period === "last30d"
+                    ? "Last 30 days"
+                    : "All time";
+            const earned = (data.totalUsd - data.bankrFeesUsd).toFixed(6);
+            console.log(`  ${label.padEnd(14)} ${data.requests} reqs  $${earned} earned  $${data.bankrFeesUsd.toFixed(6)} fees`);
+        }
+        console.log();
+    }
+    catch (err) {
+        spin.fail("Failed to fetch revenue");
+        output.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+/**
+ * bankr x402 env set KEY=VALUE
+ */
+export async function x402EnvSetCommand(keyValue) {
+    const eqIdx = keyValue.indexOf("=");
+    if (eqIdx === -1) {
+        output.error("Usage: bankr x402 env set KEY=VALUE");
+        process.exit(1);
+    }
+    const key = keyValue.slice(0, eqIdx);
+    const value = keyValue.slice(eqIdx + 1);
+    if (!key) {
+        output.error("Key cannot be empty");
+        process.exit(1);
+    }
+    const spin = output.spinner(`Setting ${key}...`);
+    try {
+        const res = await fetch(`${getApiUrl()}/x402/endpoints/env`, {
+            method: "POST",
+            headers: authHeaders(),
+            body: JSON.stringify({ vars: { [key]: value } }),
+        });
+        await handleResponse(res);
+        spin.succeed(`Set ${key}`);
+    }
+    catch (err) {
+        spin.fail(`Failed to set ${key}`);
+        output.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+/**
+ * bankr x402 env list
+ */
+export async function x402EnvListCommand() {
+    const spin = output.spinner("Fetching env vars...");
+    try {
+        const res = await fetch(`${getApiUrl()}/x402/endpoints/env`, {
+            headers: authHeaders(),
+        });
+        const result = await handleResponse(res);
+        spin.stop();
+        if (result.vars.length === 0) {
+            output.info("No environment variables set.");
+            return;
+        }
+        for (const name of result.vars) {
+            console.log(`  ${name}`);
+        }
+    }
+    catch (err) {
+        spin.fail("Failed to list env vars");
+        output.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+/**
+ * bankr x402 env unset KEY
+ */
+export async function x402EnvUnsetCommand(key) {
+    const spin = output.spinner(`Removing ${key}...`);
+    try {
+        const res = await fetch(`${getApiUrl()}/x402/endpoints/env/${key}`, {
+            method: "DELETE",
+            headers: authHeaders(),
+        });
+        await handleResponse(res);
+        spin.succeed(`Removed ${key}`);
+    }
+    catch (err) {
+        spin.fail(`Failed to remove ${key}`);
+        output.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+// ── Schema display helpers ──────────────────────────────────────────────
+const P = "  │";
+/**
+ * Detects whether a schema object is JSON Schema format (has `type` and `properties`)
+ * vs the legacy flat Record<string,string> format.
+ */
+function isJsonSchema(obj) {
+    return (typeof obj === "object" &&
+        obj !== null &&
+        "type" in obj &&
+        obj.type === "object" &&
+        "properties" in obj);
+}
+/**
+ * Renders a JSON Schema properties table.
+ * Output: lines like "  │     symbol*   string   Token symbol"
+ */
+function renderJsonSchemaProps(schema) {
+    if (!schema.properties)
+        return [];
+    const required = new Set(schema.required ?? []);
+    const entries = Object.entries(schema.properties);
+    // Calculate column widths
+    let maxName = 0;
+    let maxType = 0;
+    for (const [name, prop] of entries) {
+        const nameLen = name.length + (required.has(name) ? 1 : 0);
+        if (nameLen > maxName)
+            maxName = nameLen;
+        const typeStr = prop.type + (prop.enum ? ` (${prop.enum.join("|")})` : "");
+        if (typeStr.length > maxType)
+            maxType = typeStr.length;
+    }
+    const lines = [];
+    for (const [name, prop] of entries) {
+        const req = required.has(name) ? chalk.red("*") : " ";
+        const nameStr = `${chalk.cyan(name)}${req}`;
+        const namePad = " ".repeat(Math.max(0, maxName + 1 - name.length - (required.has(name) ? 1 : 0)));
+        const typeStr = prop.type + (prop.enum ? ` (${prop.enum.join("|")})` : "");
+        const typePad = " ".repeat(Math.max(0, maxType + 2 - typeStr.length));
+        const desc = prop.description ? chalk.dim(prop.description) : "";
+        lines.push(`${P}     ${nameStr}${namePad}${chalk.yellow(typeStr)}${typePad}${desc}`);
+    }
+    return lines;
+}
+/**
+ * Renders a legacy flat Record<string,string> schema as a simple key: value list.
+ * Pretty-prints nested objects/arrays with proper indentation.
+ */
+function renderLegacySchema(obj) {
+    const lines = [];
+    for (const [k, v] of Object.entries(obj)) {
+        if (typeof v === "object" && v !== null) {
+            const pretty = JSON.stringify(v, null, 2);
+            const indented = pretty
+                .split("\n")
+                .map((line, i) => (i === 0 ? line : `${P}       ${" ".repeat(k.length)}${line}`))
+                .join("\n");
+            lines.push(`${P}     ${chalk.cyan(k)}  ${chalk.dim(indented)}`);
+        }
+        else {
+            lines.push(`${P}     ${chalk.cyan(k)}  ${chalk.dim(String(v))}`);
+        }
+    }
+    return lines;
+}
+/**
+ * Resolves input/output schemas from a route, handling both JSON Schema
+ * and legacy flat formats for backward compatibility.
+ */
+function resolveSchemas(schema) {
+    if (!schema)
+        return { input: undefined, output: undefined };
+    // Prefer new JSON Schema `input`/`output` fields
+    const inputSchema = schema.input ?? schema.queryParams ?? schema.body;
+    const outputSchema = schema.output;
+    return { input: inputSchema, output: outputSchema };
+}
+function printServiceFormatted(svc) {
+    const route = svc.routes[0];
+    const methods = route?.methods?.filter((m) => m !== "*").join(", ") || "ANY";
+    const url = svc.url ?? `https://x402.bankr.bot/${svc.slug}`;
+    const isGet = methods === "GET";
+    // ── Card header ──
+    console.log(`  ${chalk.dim("┌")} ${output.fmt.brandBold(svc.name)}`);
+    if (svc.description) {
+        console.log(`${P} ${chalk.dim(svc.description)}`);
+    }
+    console.log(`${P}`);
+    // ── Metadata ──
+    console.log(`${P}  ${chalk.dim("URL")}       ${url}`);
+    console.log(`${P}  ${chalk.dim("Method")}    ${chalk.bold(methods)}`);
+    console.log(`${P}  ${chalk.dim("Price")}     ${chalk.green(`$${route?.price ?? "?"} ${route?.currency ?? "USDC"}`)}`);
+    console.log(`${P}  ${chalk.dim("Network")}   ${route?.network ?? "base"}`);
+    // ── Schema ──
+    const { input: inputSchema, output: outputSchema } = resolveSchemas(route?.schema);
+    if (inputSchema || outputSchema) {
+        console.log(`${P}`);
+        if (inputSchema) {
+            const label = isGet ? "Input (query params)" : "Input (JSON body)";
+            console.log(`${P}  ${chalk.bold(label)}`);
+            if (isJsonSchema(inputSchema)) {
+                for (const line of renderJsonSchemaProps(inputSchema)) {
+                    console.log(line);
+                }
+            }
+            else if (typeof inputSchema === "object" && inputSchema !== null) {
+                for (const line of renderLegacySchema(inputSchema)) {
+                    console.log(line);
+                }
+            }
+        }
+        if (outputSchema) {
+            console.log(`${P}`);
+            console.log(`${P}  ${chalk.bold("Output")}`);
+            if (isJsonSchema(outputSchema)) {
+                for (const line of renderJsonSchemaProps(outputSchema)) {
+                    console.log(line);
+                }
+            }
+            else if (typeof outputSchema === "object" && outputSchema !== null) {
+                for (const line of renderLegacySchema(outputSchema)) {
+                    console.log(line);
+                }
+            }
+        }
+    }
+    // ── Example ──
+    if (inputSchema && isJsonSchema(inputSchema) && inputSchema.properties) {
+        console.log(`${P}`);
+        const props = Object.entries(inputSchema.properties);
+        if (isGet) {
+            const qs = props.map(([k, p]) => `${k}=<${p.type}>`).join("&");
+            console.log(`${P}  ${chalk.dim("Example")}   ${chalk.dim("GET")} ${url}?${qs}`);
+        }
+        else {
+            const bodyObj = {};
+            for (const [k, p] of props)
+                bodyObj[k] = `<${p.type}>`;
+            console.log(`${P}  ${chalk.dim("Example")}   ${chalk.dim("POST")} ${url}`);
+            console.log(`${P}            ${chalk.dim(JSON.stringify(bodyObj))}`);
+        }
+    }
+    // ── Tags ──
+    if (svc.tags?.length) {
+        console.log(`${P}`);
+        console.log(`${P}  ${svc.tags.map((t) => chalk.dim(`#${t}`)).join("  ")}`);
+    }
+    console.log(`  ${chalk.dim("└" + "─".repeat(60))}`);
+    console.log();
+}
+export async function x402SearchCommand(queryParts, opts = {}) {
+    const query = queryParts.join(" ").trim();
+    if (!query) {
+        output.error("Usage: bankr x402 search <query>");
+        process.exit(1);
+    }
+    const spin = output.spinner("Searching services...");
+    try {
+        const params = new URLSearchParams({ q: query, limit: "10" });
+        const res = await fetch(`${getApiUrl()}/x402/endpoints/discover?${params}`);
+        const result = await handleResponse(res);
+        spin.stop();
+        if (result.services.length === 0) {
+            output.info(`No services found for "${query}"`);
+            return;
+        }
+        // Raw mode: dump JSON and exit
+        if (opts.raw) {
+            console.log(JSON.stringify(result.services, null, 2));
+            return;
+        }
+        console.log();
+        console.log(`  ${chalk.dim(`Found ${result.services.length} service(s) for`)} "${query}"`);
+        console.log(`  ${chalk.dim("─".repeat(60))}`);
+        for (const svc of result.services) {
+            printServiceFormatted(svc);
+        }
+    }
+    catch (err) {
+        spin.fail("Search failed");
+        output.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=x402.js.map

package/dist/lib/chains.js

@@ -5,6 +5,7 @@ export const CHAIN_LABELS = {
     unichain: "Unichain",
     worldchain: "World Chain",
     arbitrum: "Arbitrum",
+    bnb: "BNB Chain",
     solana: "Solana",
 };
 export const VALID_CHAINS = new Set([
@@ -14,6 +15,7 @@ export const VALID_CHAINS = new Set([
     "unichain",
     "worldchain",
     "arbitrum",
+    "bnb",
     "solana",
 ]);
 export const CHAIN_IDS = {
@@ -23,6 +25,7 @@ export const CHAIN_IDS = {
     unichain: 130,
     worldchain: 480,
     arbitrum: 42161,
+    bnb: 56,
 };
 export const NATIVE_SYMBOLS = {
     base: "ETH",
@@ -31,5 +34,6 @@ export const NATIVE_SYMBOLS = {
     worldchain: "ETH",
     arbitrum: "ETH",
     polygon: "POL",
+    bnb: "BNB",
 };
 //# sourceMappingURL=chains.js.map

package/dist/lib/output.d.ts

@@ -4,6 +4,8 @@ export declare const fmt: {
     readonly brand: import("chalk").ChalkInstance;
     readonly brandBold: import("chalk").ChalkInstance;
     readonly dim: import("chalk").ChalkInstance;
+    readonly success: import("chalk").ChalkInstance;
+    readonly warn: import("chalk").ChalkInstance;
 };
 export declare const bankrTheme: {
     prefix: string;

package/dist/lib/output.js

@@ -8,6 +8,8 @@ export const fmt = {
     brand: brandColor,
     brandBold: brandColorBold,
     dim: chalk.dim,
+    success: chalk.green,
+    warn: chalk.yellow,
 };
 export const bankrTheme = {
     prefix: brandColor("▸"),

package/dist/lib/updateCheck.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Non-blocking update check. Call at the end of main().
+ * - Checks npm registry at most once every 4 hours (cached)
+ * - Prints a one-line notice if a newer version exists
+ * - Never throws, never delays CLI exit
+ */
+export declare function checkForUpdate(currentVersion: string): Promise<void>;
+//# sourceMappingURL=updateCheck.d.ts.map

package/dist/lib/updateCheck.js

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import chalk from "chalk";
+const PACKAGE_NAME = "@bankr/cli";
+const CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
+const CACHE_DIR = join(homedir(), ".bankr");
+const CACHE_FILE = join(CACHE_DIR, "update-check.json");
+function readCache() {
+    try {
+        if (!existsSync(CACHE_FILE))
+            return null;
+        return JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(cache) {
+    try {
+        if (!existsSync(CACHE_DIR))
+            mkdirSync(CACHE_DIR, { recursive: true });
+        writeFileSync(CACHE_FILE, JSON.stringify(cache));
+    }
+    catch {
+        // Silent — cache is best-effort
+    }
+}
+function compareSemver(a, b) {
+    const partsA = a.split(".").map(Number);
+    const partsB = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+        const numA = partsA[i] ?? 0;
+        const numB = partsB[i] ?? 0;
+        if (numA < numB)
+            return -1;
+        if (numA > numB)
+            return 1;
+    }
+    return 0;
+}
+/**
+ * Non-blocking update check. Call at the end of main().
+ * - Checks npm registry at most once every 4 hours (cached)
+ * - Prints a one-line notice if a newer version exists
+ * - Never throws, never delays CLI exit
+ */
+export async function checkForUpdate(currentVersion) {
+    try {
+        // Check cache first
+        const cache = readCache();
+        if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
+            if (compareSemver(currentVersion, cache.latestVersion) < 0) {
+                printNotice(currentVersion, cache.latestVersion);
+            }
+            return;
+        }
+        // Fetch latest with a short timeout
+        const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { signal: AbortSignal.timeout(3000) });
+        if (!res.ok)
+            return;
+        const data = (await res.json());
+        const latest = data.version;
+        writeCache({ lastCheck: Date.now(), latestVersion: latest });
+        if (compareSemver(currentVersion, latest) < 0) {
+            printNotice(currentVersion, latest);
+        }
+    }
+    catch {
+        // Silent — never block the CLI for update checks
+    }
+}
+function printNotice(current, latest) {
+    console.log();
+    console.log(chalk.yellow(`  Update available: ${current} → ${latest}`));
+    console.log(chalk.dim(`  Run ${chalk.white("bankr update")} to update`));
+}
+//# sourceMappingURL=updateCheck.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bankr/cli",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Official CLI for the Bankr AI agent platform",
   "type": "module",
   "bin": {