@bankr/cli 0.1.3 → 0.2.2

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