@bankr/cli 0.2.0 → 0.2.2

package/dist/cli.js

@@ -22,6 +22,7 @@ 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";
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
@@ -712,6 +713,65 @@ 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)")
+    .action(async (query) => x402SearchCommand(query));
 // Default: treat unrecognized arguments as a prompt
 program
     .arguments("[text...]")

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,69 @@
+/**
+ * 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>;
+/**
+ * bankr x402 search <query> — Search the x402 service marketplace
+ *
+ * Public — no auth required. Uses vector search + keyword matching
+ * to find relevant paid API services.
+ */
+export declare function x402SearchCommand(queryParts: string[]): Promise<void>;
+//# sourceMappingURL=x402.d.ts.map

package/dist/commands/x402.js

@@ -0,0 +1,636 @@
+/**
+ * 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 { 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 schema scaffold based on method
+    const schema = {};
+    if (isPost) {
+        schema.body = { field: "string" };
+    }
+    else if (method === "GET") {
+        schema.queryParams = { param: "string" };
+    }
+    schema.output = { result: "string" };
+    // 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);
+    }
+}
+/**
+ * bankr x402 search <query> — Search the x402 service marketplace
+ *
+ * Public — no auth required. Uses vector search + keyword matching
+ * to find relevant paid API services.
+ */
+export async function x402SearchCommand(queryParts) {
+    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;
+        }
+        console.log();
+        output.dim(`  Found ${result.services.length} service(s) for "${query}"`);
+        console.log();
+        for (const svc of result.services) {
+            const route = svc.routes[0];
+            const price = route ? `$${route.price} ${route.currency}` : "—";
+            const methods = route?.methods?.filter((m) => m !== "*").join(", ") || "ANY";
+            const score = svc.score
+                ? `  ${output.fmt.dim(`${(svc.score * 100).toFixed(0)}% match`)}`
+                : "";
+            console.log(`  ${output.fmt.brand(svc.name)}${score}`);
+            if (svc.description) {
+                output.dim(`    ${svc.description}`);
+            }
+            const url = svc.url ?? `https://x402.bankr.bot/${svc.slug}`;
+            console.log(`    ${output.fmt.dim("Method:")} ${methods}  ${output.fmt.dim("Price:")} ${price}  ${output.fmt.dim("Network:")} ${route?.network ?? "base"}`);
+            output.dim(`    ${url}`);
+            // Show schema if available
+            const qp = route?.schema?.queryParams ??
+                (methods === "GET" ? route?.schema?.input : undefined);
+            const body = route?.schema?.body ??
+                (methods !== "GET" ? route?.schema?.input : undefined);
+            if (qp) {
+                const fields = Object.entries(qp)
+                    .map(([k, v]) => `${k}=${v}`)
+                    .join("&");
+                output.dim(`    ${output.fmt.dim("Params:")} ?${fields}`);
+            }
+            if (body) {
+                const fields = Object.entries(body)
+                    .map(([k, v]) => `${k}: ${v}`)
+                    .join(", ");
+                output.dim(`    ${output.fmt.dim("Body:")} { ${fields} }`);
+            }
+            if (route?.schema?.output) {
+                const fields = Object.entries(route.schema.output)
+                    .map(([k, v]) => `${k}: ${v}`)
+                    .join(", ");
+                output.dim(`    ${output.fmt.dim("Returns:")} { ${fields} }`);
+            }
+            console.log();
+        }
+    }
+    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/package.json

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