@bankr/cli 0.2.7 → 0.2.9

package/dist/cli.js

@@ -22,7 +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 { x402InitCommand, x402AddCommand, x402ConfigureCommand, x402DeployCommand, x402ListCommand, x402PauseResumeCommand, x402DeleteCommand, x402RevenueCommand, x402EnvSetCommand, x402EnvListCommand, x402EnvUnsetCommand, x402SearchCommand, x402SchemaCommand, x402CallCommand, } 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";
@@ -774,6 +774,21 @@ x402Cmd
     .description("Search the x402 service marketplace (no auth required)")
     .option("--raw", "Output raw JSON (unformatted)")
     .action(async (query, opts) => x402SearchCommand(query, { raw: opts.raw }));
+x402Cmd
+    .command("schema <url>")
+    .description("View input/output schema for a Bankr x402 endpoint (no auth required)")
+    .option("--raw", "Output raw JSON (unformatted)")
+    .action(async (url, opts) => x402SchemaCommand(url, opts));
+x402Cmd
+    .command("call <url>")
+    .description("Call an x402-protected endpoint with automatic USDC payment")
+    .option("-X, --method <method>", "HTTP method (GET, POST, PUT, DELETE)", "GET")
+    .option("-d, --body <json>", "JSON request body")
+    .option("--max-payment <usd>", "Maximum payment in USD (default: 1, max: 10)", "1")
+    .option("-i, --interactive", "Fetch endpoint schema and prompt for input values")
+    .option("-y, --yes", "Skip payment confirmation")
+    .option("--raw", "Output raw JSON (unformatted)")
+    .action(async (url, opts) => x402CallCommand(url, opts));
 // Default: treat unrecognized arguments as a prompt
 program
     .arguments("[text...]")

package/dist/commands/x402.d.ts

@@ -59,6 +59,17 @@ export declare function x402EnvListCommand(): Promise<void>;
  * bankr x402 env unset KEY
  */
 export declare function x402EnvUnsetCommand(key: string): Promise<void>;
+export declare function x402SchemaCommand(url: string, opts?: {
+    raw?: boolean;
+}): Promise<void>;
+export declare function x402CallCommand(url: string, opts?: {
+    method?: string;
+    body?: string;
+    maxPayment?: string;
+    yes?: boolean;
+    raw?: boolean;
+    interactive?: boolean;
+}): Promise<void>;
 export declare function x402SearchCommand(queryParts: string[], opts?: {
     raw?: boolean;
 }): Promise<void>;

package/dist/commands/x402.js

@@ -741,6 +741,479 @@ function printServiceFormatted(svc) {
     console.log(`  ${chalk.dim("─".repeat(60))}`);
     console.log("");
 }
+// ── Schema ────────────────────────────────────────────────────────────
+export async function x402SchemaCommand(url, opts = {}) {
+    if (!url) {
+        output.error("Usage: bankr x402 schema <url>\n  Example: bankr x402 schema https://x402.bankr.bot/0xabc.../my-service");
+        process.exit(1);
+    }
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        output.error("Invalid URL");
+        process.exit(1);
+        return; // unreachable but makes TS happy
+    }
+    if (!parsed.hostname.endsWith("x402.bankr.bot")) {
+        output.error("Schema lookup is only available for Bankr-hosted endpoints (x402.bankr.bot).");
+        process.exit(1);
+    }
+    const parts = parsed.pathname.split("/").filter(Boolean);
+    if (parts.length < 2) {
+        output.error("Invalid Bankr x402 URL. Expected: https://x402.bankr.bot/<address>/<service>");
+        process.exit(1);
+    }
+    const spin = output.spinner("Fetching endpoint schema...");
+    try {
+        const res = await fetch(`${getApiUrl()}/x402/endpoints/schema/${parts[0]}/${parts[1]}`);
+        if (res.status === 404) {
+            spin.fail("Endpoint not found");
+            output.error(`No active endpoint found for ${parts[0]}/${parts[1]}`);
+            process.exit(1);
+        }
+        const result = await handleResponse(res);
+        spin.stop();
+        if (opts.raw) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        // Header
+        console.log();
+        console.log(`  ${chalk.bold(result.name)}`);
+        if (result.description) {
+            console.log(`  ${chalk.dim(result.description)}`);
+        }
+        console.log();
+        // Metadata
+        console.log(`    ${chalk.dim("URL")}       ${url}`);
+        console.log(`    ${chalk.dim("Method")}    ${chalk.bold(result.methods.join(", ") || "GET")}`);
+        console.log(`    ${chalk.dim("Price")}     ${chalk.green(`$${result.price} ${result.currency}`)}`);
+        console.log(`    ${chalk.dim("Network")}   ${result.network}`);
+        // Input schema
+        if (result.schema?.input) {
+            console.log();
+            const isGet = result.methods.includes("GET") && !result.methods.includes("POST");
+            const label = isGet ? "Input (query params)" : "Input (JSON body)";
+            console.log(`    ${chalk.bold(label)}`);
+            if (isJsonSchema(result.schema.input)) {
+                for (const line of renderJsonSchemaProps(result.schema.input)) {
+                    console.log(line);
+                }
+            }
+            else {
+                for (const line of renderLegacySchema(result.schema.input)) {
+                    console.log(line);
+                }
+            }
+            // Example
+            if (isJsonSchema(result.schema.input) &&
+                result.schema.input.properties) {
+                const props = Object.entries(result.schema.input.properties);
+                console.log();
+                if (isGet) {
+                    const qs = props.map(([k, p]) => `${k}=<${p.type}>`).join("&");
+                    console.log(`    ${chalk.dim("Example")}   ${chalk.dim("GET")} ${url}?${qs}`);
+                }
+                else {
+                    const bodyObj = {};
+                    for (const [k, p] of props)
+                        bodyObj[k] = `<${p.type}>`;
+                    console.log(`    ${chalk.dim("Example")}   ${chalk.dim(result.methods[0] || "POST")} ${url}`);
+                    console.log(`              ${chalk.dim(JSON.stringify(bodyObj))}`);
+                }
+            }
+        }
+        // Output schema
+        if (result.schema?.output) {
+            console.log();
+            console.log(`    ${chalk.bold("Output")}`);
+            if (isJsonSchema(result.schema.output)) {
+                for (const line of renderJsonSchemaProps(result.schema.output)) {
+                    console.log(line);
+                }
+            }
+            else {
+                for (const line of renderLegacySchema(result.schema.output)) {
+                    console.log(line);
+                }
+            }
+        }
+        if (!result.schema?.input && !result.schema?.output) {
+            console.log();
+            console.log(`    ${chalk.dim("No input/output schema defined for this endpoint.")}`);
+        }
+        // Tags
+        if (result.tags?.length) {
+            console.log();
+            console.log(`    ${result.tags.map((t) => chalk.dim(`#${t}`)).join("  ")}`);
+        }
+        console.log(`  ${chalk.dim("─".repeat(60))}`);
+        console.log();
+    }
+    catch (err) {
+        spin.fail("Schema lookup failed");
+        output.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+async function fetchSchemaForInteractive(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    const isBankr = parsed.hostname.endsWith("x402.bankr.bot");
+    const parts = parsed.pathname.split("/").filter(Boolean);
+    // Strategy 1: Direct schema API (works once deployed)
+    if (isBankr && parts.length >= 2) {
+        try {
+            const res = await fetch(`${getApiUrl()}/x402/endpoints/schema/${parts[0]}/${parts[1]}`);
+            if (res.ok) {
+                const data = (await res.json());
+                if (data.success) {
+                    const rawInput = data.schema?.input;
+                    const inputSchema = rawInput && isJsonSchema(rawInput)
+                        ? rawInput
+                        : null;
+                    return {
+                        name: data.name,
+                        description: data.description,
+                        methods: data.methods,
+                        price: data.price,
+                        currency: data.currency,
+                        inputSchema,
+                    };
+                }
+            }
+        }
+        catch {
+            // Fall through to next strategy
+        }
+    }
+    // Strategy 2: Discover API (already deployed, searches by service name)
+    if (isBankr && parts.length >= 2) {
+        try {
+            const serviceName = parts[parts.length - 1];
+            const discoverRes = await fetch(`${getApiUrl()}/x402/endpoints/discover?${new URLSearchParams({ q: serviceName, limit: "5" })}`);
+            if (discoverRes.ok) {
+                const discoverData = (await discoverRes.json());
+                // Match by slug or URL path
+                const slug = `${parts[0]}/${parts[1]}`;
+                const match = discoverData.services?.find((s) => s.slug === slug || s.slug.endsWith(`/${serviceName}`));
+                if (match) {
+                    const route = match.routes?.[0];
+                    const { input: rawInput } = resolveSchemas(route?.schema);
+                    const inputSchema = rawInput && isJsonSchema(rawInput)
+                        ? rawInput
+                        : null;
+                    return {
+                        name: match.name,
+                        description: match.description,
+                        methods: route?.methods?.filter((m) => m !== "*") ?? ["GET"],
+                        price: route?.price ?? "?",
+                        currency: route?.currency ?? "USDC",
+                        inputSchema,
+                    };
+                }
+            }
+        }
+        catch {
+            // Fall through to next strategy
+        }
+    }
+    // Strategy 3: Probe endpoint for 402 response to get price info.
+    // Checks header first (Bankr endpoints), then falls back to response
+    // body (Coinbase x402 standard used by external endpoints).
+    try {
+        const probeRes = await fetch(url, { method: "GET" });
+        if (probeRes.status === 402) {
+            const paymentHeader = probeRes.headers.get("payment-required") ??
+                probeRes.headers.get("x-payment-required");
+            let accept = null;
+            if (paymentHeader) {
+                try {
+                    const decoded = Buffer.from(paymentHeader, "base64").toString("utf-8");
+                    const requirements = JSON.parse(decoded);
+                    accept = requirements.accepts?.[0] ?? requirements;
+                }
+                catch {
+                    // Header parse failed, try body
+                }
+            }
+            if (!accept) {
+                try {
+                    const bodyText = await probeRes.text();
+                    const bodyJson = JSON.parse(bodyText);
+                    accept = bodyJson.accepts?.[0] ?? null;
+                }
+                catch {
+                    // Body parse failed too
+                }
+            }
+            const acceptAmount = accept?.maxAmountRequired ?? accept?.amount;
+            if (acceptAmount) {
+                const amountAtomic = BigInt(acceptAmount);
+                const amountUsd = Number(amountAtomic) / 1000000;
+                // Extract service name from URL path
+                const serviceName = parts[parts.length - 1] ?? "endpoint";
+                return {
+                    name: serviceName,
+                    description: accept?.description ?? "",
+                    methods: ["GET"],
+                    price: amountUsd.toFixed(6),
+                    currency: "USDC",
+                    inputSchema: null,
+                };
+            }
+        }
+    }
+    catch {
+        // Fall through
+    }
+    return null;
+}
+// ── Call ──────────────────────────────────────────────────────────────
+export async function x402CallCommand(url, opts = {}) {
+    if (!url) {
+        output.error("Usage: bankr x402 call <url> [--method POST] [--body '{}']");
+        process.exit(1);
+    }
+    let method = opts.method?.toUpperCase() ?? "GET";
+    const maxPaymentUsd = opts.maxPayment ? parseFloat(opts.maxPayment) : 1;
+    let requestBody = opts.body;
+    if (isNaN(maxPaymentUsd) || maxPaymentUsd <= 0 || maxPaymentUsd > 10) {
+        output.error("--max-payment must be between 0 and 10 (USD)");
+        process.exit(1);
+    }
+    // Interactive mode: fetch schema and prompt for input values
+    let resolvedPrice = null;
+    if (opts.interactive) {
+        const schema = await fetchSchemaForInteractive(url);
+        if (schema) {
+            // Full schema available — show endpoint info and prompt for fields
+            console.log();
+            console.log(`  ${chalk.bold(schema.name)}`);
+            if (schema.description) {
+                console.log(`  ${chalk.dim(schema.description)}`);
+            }
+            console.log(`  ${chalk.dim("Price")}  ${chalk.green(`$${schema.price} ${schema.currency}`)}`);
+            console.log();
+            // Use the endpoint's actual price and preferred method
+            resolvedPrice = parseFloat(schema.price);
+            if (schema.methods.length > 0) {
+                method = schema.methods.includes("POST") ? "POST" : schema.methods[0];
+            }
+            // Prompt for each input field
+            if (schema.inputSchema && schema.inputSchema.properties) {
+                const required = new Set(schema.inputSchema.required ?? []);
+                const values = {};
+                for (const [key, prop] of Object.entries(schema.inputSchema.properties)) {
+                    const typedProp = prop;
+                    const isRequired = required.has(key);
+                    const label = isRequired
+                        ? `${chalk.bold(key)} ${chalk.dim(`(${typedProp.type})`)}`
+                        : `${key} ${chalk.dim(`(${typedProp.type}, optional)`)}`;
+                    const hint = typedProp.description ?? "";
+                    // Enum fields → select prompt
+                    if (typedProp.enum && typedProp.enum.length > 0) {
+                        const selected = await select({
+                            message: `${label}${hint ? ` — ${chalk.dim(hint)}` : ""}`,
+                            choices: typedProp.enum.map((v) => ({
+                                name: String(v),
+                                value: String(v),
+                            })),
+                        });
+                        values[key] =
+                            typedProp.type === "number" || typedProp.type === "integer"
+                                ? Number(selected)
+                                : selected;
+                    }
+                    else {
+                        // Text input
+                        const answer = await input({
+                            message: `${label}${hint ? ` — ${chalk.dim(hint)}` : ""}`,
+                            required: isRequired,
+                        });
+                        if (answer === "" && !isRequired)
+                            continue;
+                        // Coerce types
+                        if (typedProp.type === "number" || typedProp.type === "integer") {
+                            const num = Number(answer);
+                            if (isNaN(num)) {
+                                output.error(`Invalid number for ${key}: "${answer}"`);
+                                process.exit(1);
+                            }
+                            values[key] = num;
+                        }
+                        else if (typedProp.type === "boolean") {
+                            values[key] = answer.toLowerCase() === "true" || answer === "1";
+                        }
+                        else {
+                            values[key] = answer;
+                        }
+                    }
+                }
+                if (Object.keys(values).length > 0) {
+                    if (method === "GET") {
+                        // Append as query params
+                        const params = new URLSearchParams();
+                        for (const [k, v] of Object.entries(values)) {
+                            params.set(k, String(v));
+                        }
+                        url = `${url}${url.includes("?") ? "&" : "?"}${params.toString()}`;
+                    }
+                    else {
+                        requestBody = JSON.stringify(values);
+                    }
+                }
+            }
+        }
+        else {
+            // No schema available — fallback: prompt for method and body
+            output.warn("No schema found for this endpoint. Falling back to manual input.");
+            console.log();
+            method = await select({
+                message: "HTTP method",
+                choices: [
+                    { name: "GET", value: "GET" },
+                    { name: "POST", value: "POST" },
+                    { name: "PUT", value: "PUT" },
+                    { name: "DELETE", value: "DELETE" },
+                ],
+                default: method,
+                theme: output.bankrTheme,
+            });
+            if (method === "POST" || method === "PUT") {
+                const bodyInput = await input({
+                    message: "JSON body (or leave empty)",
+                    theme: output.bankrTheme,
+                });
+                if (bodyInput.trim()) {
+                    try {
+                        JSON.parse(bodyInput);
+                        requestBody = bodyInput;
+                    }
+                    catch {
+                        output.error("Invalid JSON body");
+                        process.exit(1);
+                    }
+                }
+            }
+            else {
+                const qsInput = await input({
+                    message: "Query params (key=val&key2=val2, or leave empty)",
+                    theme: output.bankrTheme,
+                });
+                if (qsInput.trim()) {
+                    url = `${url}${url.includes("?") ? "&" : "?"}${qsInput}`;
+                }
+            }
+        }
+        // Show what we're about to send
+        console.log(`  ${chalk.dim("─".repeat(60))}`);
+        console.log(`  ${chalk.dim("Method")}   ${method}`);
+        console.log(`  ${chalk.dim("URL")}      ${url}`);
+        if (requestBody) {
+            console.log(`  ${chalk.dim("Body")}     ${requestBody}`);
+        }
+        console.log();
+    }
+    // Non-interactive: probe the endpoint to show the actual price before confirming
+    if (!opts.interactive && !opts.yes && resolvedPrice === null) {
+        const spin = output.spinner("Checking endpoint price...");
+        const schema = await fetchSchemaForInteractive(url);
+        spin.stop();
+        if (schema) {
+            resolvedPrice = parseFloat(schema.price);
+        }
+    }
+    // Confirm payment unless --yes
+    if (!opts.yes && !opts.interactive) {
+        const priceDisplay = resolvedPrice !== null
+            ? chalk.green(`$${resolvedPrice} USDC`)
+            : chalk.green(`up to $${maxPaymentUsd} USDC`);
+        const confirmed = await confirm({
+            message: `Call ${chalk.bold(url)} with ${priceDisplay} payment?`,
+            default: true,
+        });
+        if (!confirmed) {
+            output.info("Cancelled.");
+            return;
+        }
+    }
+    else if (opts.interactive) {
+        const confirmed = await confirm({
+            message: `Submit with ${chalk.green(`$${resolvedPrice ?? maxPaymentUsd} USDC`)} payment?`,
+            default: true,
+        });
+        if (!confirmed) {
+            output.info("Cancelled.");
+            return;
+        }
+    }
+    const spin = output.spinner(`Calling ${method} ${url}...`);
+    try {
+        const res = await fetch(`${getApiUrl()}/wallet/x402-pay`, {
+            method: "POST",
+            headers: authHeaders(),
+            body: JSON.stringify({
+                url,
+                method,
+                body: requestBody,
+                maxPaymentUsd: resolvedPrice ?? maxPaymentUsd,
+            }),
+        });
+        const result = await handleResponse(res);
+        spin.stop();
+        if (opts.raw) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (!result.success) {
+            output.error(result.error ?? "Call failed");
+            process.exit(1);
+        }
+        // Show endpoint schema info (Bankr-hosted endpoints only)
+        if (result.endpointSchema) {
+            const ep = result.endpointSchema;
+            console.log();
+            console.log(`  ${chalk.dim("Endpoint")}  ${chalk.bold(ep.name)} — ${ep.description}`);
+            if (ep.schema?.input) {
+                console.log(`  ${chalk.dim("Input")}     ${chalk.dim(JSON.stringify(ep.schema.input))}`);
+            }
+            if (ep.schema?.output) {
+                console.log(`  ${chalk.dim("Output")}    ${chalk.dim(JSON.stringify(ep.schema.output))}`);
+            }
+        }
+        // Show payment info
+        if (result.paymentMade) {
+            console.log();
+            console.log(`  ${chalk.green("Paid")} ${chalk.bold(`$${result.paymentMade.amountUsd.toFixed(4)}`)} USDC on ${result.paymentMade.network}`);
+        }
+        // Show response
+        console.log();
+        console.log(`  ${chalk.dim("Status")}   ${result.status}`);
+        console.log(`  ${chalk.dim("Response")}`);
+        console.log();
+        if (typeof result.response === "string") {
+            console.log(`  ${result.response}`);
+        }
+        else {
+            console.log(JSON.stringify(result.response, null, 2));
+        }
+        console.log();
+    }
+    catch (err) {
+        spin.fail("Call failed");
+        output.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+// ── Search ────────────────────────────────────────────────────────────
 export async function x402SearchCommand(queryParts, opts = {}) {
     const query = queryParts.join(" ").trim();
     if (!query) {

package/dist/lib/api.d.ts

@@ -381,5 +381,24 @@ export interface TransferResponse {
     error?: string;
 }
 export declare function transfer(request: TransferRequest): Promise<TransferResponse>;
+export interface X402PayRequest {
+    url: string;
+    method?: string;
+    body?: string;
+    headers?: Record<string, string>;
+    maxPaymentUsd?: number;
+}
+export interface X402PayResponse {
+    success: boolean;
+    status?: number;
+    response?: unknown;
+    paymentMade?: {
+        amountUsd: number;
+        network: string;
+        payTo: string;
+    };
+    error?: string;
+}
+export declare function x402Pay(request: X402PayRequest): Promise<X402PayResponse>;
 export declare function buildPublicClaimTxs(beneficiaryAddress: string, tokenAddresses: string[]): Promise<BuildClaimResponse>;
 //# sourceMappingURL=api.d.ts.map

package/dist/lib/api.js

@@ -280,6 +280,14 @@ export async function transfer(request) {
     });
     return handleResponse(res);
 }
+export async function x402Pay(request) {
+    const res = await fetch(`${getApiUrl()}/wallet/x402-pay`, {
+        method: "POST",
+        headers: authHeaders(),
+        body: JSON.stringify(request),
+    });
+    return handleResponse(res);
+}
 export async function buildPublicClaimTxs(beneficiaryAddress, tokenAddresses) {
     const res = await fetch(`${getApiUrl()}/public/doppler/build-claim`, {
         method: "POST",

package/dist/lib/output.js

@@ -61,6 +61,13 @@ export function spinner(text) {
 export function maskApiKey(key) {
     if (key.length <= 8)
         return "****";
+    // New prefixed keys: bk_usr_{keyId}_{secret} → bk_usr_{keyId}_*****
+    const parts = key.split("_");
+    if (parts.length === 4 &&
+        parts[0] === "bk" &&
+        (parts[1] === "usr" || parts[1] === "ptr")) {
+        return `${parts[0]}_${parts[1]}_${parts[2]}_*****`;
+    }
     return key.slice(0, 6) + "..." + key.slice(-4);
 }
 export function formatDuration(ms) {

package/package.json

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