@bankr/cli 0.2.2 → 0.2.3

package/dist/cli.js

@@ -25,6 +25,7 @@ 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.
@@ -771,7 +772,8 @@ x402EnvCmd
 x402Cmd
     .command("search [query...]")
     .description("Search the x402 service marketplace (no auth required)")
-    .action(async (query) => x402SearchCommand(query));
+    .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...]")
@@ -797,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/x402.d.ts

@@ -59,11 +59,7 @@ 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>;
+export declare function x402SearchCommand(queryParts: string[], opts?: {
+    raw?: boolean;
+}): Promise<void>;
 //# sourceMappingURL=x402.d.ts.map

package/dist/commands/x402.js

@@ -17,6 +17,7 @@
  */
 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";
@@ -202,15 +203,25 @@ export default async function handler(req: Request): Promise<Response> {
 }
 `;
     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" };
+    // 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) {
@@ -562,13 +573,158 @@ export async function x402EnvUnsetCommand(key) {
         process.exit(1);
     }
 }
+// ── Schema display helpers ──────────────────────────────────────────────
+const P = "  │";
 /**
- * bankr x402 search <query> — Search the x402 service marketplace
- *
- * Public — no auth required. Uses vector search + keyword matching
- * to find relevant paid API services.
+ * 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.
  */
-export async function x402SearchCommand(queryParts) {
+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>");
@@ -584,47 +740,16 @@ export async function x402SearchCommand(queryParts) {
             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();
-        output.dim(`  Found ${result.services.length} service(s) for "${query}"`);
-        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) {
-            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();
+            printServiceFormatted(svc);
         }
     }
     catch (err) {

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.2",
+  "version": "0.2.3",
   "description": "Official CLI for the Bankr AI agent platform",
   "type": "module",
   "bin": {