@bankr/cli 0.1.3 → 0.2.2

package/dist/commands/tokens.js

@@ -0,0 +1,60 @@
+import { searchTokens } from "../lib/api.js";
+import * as output from "../lib/output.js";
+export async function tokensSearchCommand(query, opts) {
+    const spin = output.spinner(`Searching tokens for "${query}"...`);
+    try {
+        const chainId = opts.chain ? Number(opts.chain) : undefined;
+        const res = await searchTokens(query, chainId);
+        spin.succeed(`Found ${res.tokens.length} result(s)`);
+        if (res.tokens.length === 0) {
+            output.info("No tokens found. Try a different search query.");
+            return;
+        }
+        console.log();
+        for (const token of res.tokens) {
+            const price = token.priceUsd
+                ? `$${token.priceUsd.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 6 })}`
+                : output.fmt.dim("n/a");
+            console.log(`  ${output.fmt.brandBold(`${token.symbol}`)} ${output.fmt.dim(token.name)}`);
+            console.log(`    Address:  ${token.address}`);
+            console.log(`    Price:    ${price}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        spin.fail(`Search failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+export async function tokensInfoCommand(address, opts) {
+    const spin = output.spinner(`Fetching token info for ${address}...`);
+    try {
+        const chainId = opts.chain ? Number(opts.chain) : undefined;
+        const res = await searchTokens(address, chainId);
+        spin.succeed("Token info loaded");
+        // Match by the requested address (search returns all tokens from matching pools)
+        const addressLower = address.toLowerCase();
+        const token = res.tokens.find((t) => t.address.toLowerCase() === addressLower) ??
+            res.tokens[0];
+        if (!token) {
+            output.error("Token not found. Check the address and try again.");
+            process.exit(1);
+        }
+        console.log();
+        output.label("Name", token.name);
+        output.label("Symbol", token.symbol);
+        output.label("Address", token.address);
+        output.label("Decimals", String(token.decimals));
+        if (token.priceUsd) {
+            output.label("Price", `$${token.priceUsd.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 6 })}`);
+        }
+        if (token.logoURI) {
+            output.label("Logo", token.logoURI);
+        }
+    }
+    catch (err) {
+        spin.fail(`Failed to fetch token info: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=tokens.js.map

package/dist/commands/transfer.d.ts

@@ -0,0 +1,8 @@
+export declare function transferCommand(opts: {
+    to: string;
+    amount: string;
+    token?: string;
+    native?: boolean;
+    chain?: string;
+}): Promise<void>;
+//# sourceMappingURL=transfer.d.ts.map

package/dist/commands/transfer.js

@@ -0,0 +1,80 @@
+import { transfer, searchTokens } from "../lib/api.js";
+import * as output from "../lib/output.js";
+import { NATIVE_SYMBOLS, CHAIN_IDS } from "../lib/chains.js";
+import { isAddress } from "viem";
+/**
+ * Resolve a token symbol or address to a contract address.
+ * If it's already a valid address, return as-is. Otherwise search by symbol.
+ */
+async function resolveToken(tokenInput, chain) {
+    if (isAddress(tokenInput)) {
+        return { address: tokenInput, symbol: tokenInput };
+    }
+    const chainId = CHAIN_IDS[chain];
+    const res = await searchTokens(tokenInput, chainId);
+    // Exact symbol match (case-insensitive) to avoid resolving to wrong token
+    const inputUpper = tokenInput.toUpperCase();
+    const exactMatch = res.tokens.find((t) => t.symbol.toUpperCase() === inputUpper);
+    if (!exactMatch) {
+        const available = res.tokens
+            .slice(0, 5)
+            .map((t) => `${t.symbol} (${t.address})`)
+            .join(", ");
+        throw new Error(`No exact match for "${tokenInput}" on ${chain}. Did you mean: ${available || "no results"}`);
+    }
+    return { address: exactMatch.address, symbol: exactMatch.symbol };
+}
+export async function transferCommand(opts) {
+    const isNative = opts.native ?? false;
+    const chain = opts.chain ?? "base";
+    if (!isNative && !opts.token) {
+        output.error("Token required for ERC20 transfers. Use --token <symbol or address> or --native.");
+        process.exit(1);
+    }
+    let tokenAddress;
+    let tokenLabel;
+    if (isNative) {
+        tokenAddress = "0x0000000000000000000000000000000000000000";
+        tokenLabel = NATIVE_SYMBOLS[chain] ?? "ETH";
+    }
+    else {
+        const spin = output.spinner(`Resolving token "${opts.token}"...`);
+        try {
+            const resolved = await resolveToken(opts.token, chain);
+            tokenAddress = resolved.address;
+            tokenLabel = resolved.symbol;
+            if (tokenAddress !== opts.token) {
+                spin.succeed(`Resolved ${opts.token} → ${tokenLabel} (${tokenAddress})`);
+            }
+            else {
+                spin.stop();
+            }
+        }
+        catch (err) {
+            spin.fail(err.message);
+            process.exit(1);
+        }
+    }
+    const chainLabel = chain !== "base" ? ` on ${chain}` : "";
+    const spin = output.spinner(`Transferring ${opts.amount} ${tokenLabel} to ${opts.to}${chainLabel}...`);
+    try {
+        const result = await transfer({
+            tokenAddress,
+            recipientAddress: opts.to,
+            amount: opts.amount,
+            isNativeToken: isNative,
+            chain,
+        });
+        if (!result.success) {
+            spin.fail(`Transfer failed: ${result.error}`);
+            process.exit(1);
+        }
+        spin.succeed(`Transfer successful`);
+        output.label("Tx Hash", result.txHash ?? "unknown");
+    }
+    catch (err) {
+        spin.fail(`Transfer failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=transfer.js.map

package/dist/commands/update.d.ts

@@ -0,0 +1,4 @@
+export declare function updateCommand(opts: {
+    check?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/update.js

@@ -0,0 +1,116 @@
+import { readFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import * as output from "../lib/output.js";
+const PACKAGE_NAME = "@bankr/cli";
+/**
+ * Compare two semver version strings.
+ * Returns -1 if a < b, 0 if equal, 1 if a > b.
+ */
+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;
+}
+async function fetchLatestVersion() {
+    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to check for updates (HTTP ${res.status})`);
+    }
+    const data = (await res.json());
+    return data.version;
+}
+function getCurrentVersion() {
+    const pkg = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
+    return pkg.version;
+}
+/**
+ * Detect which package manager installed the CLI globally.
+ * Falls back to npm if we can't determine.
+ */
+function detectPackageManager() {
+    try {
+        const execPath = process.argv[1] ?? "";
+        // Check if running under bun
+        if (execPath.includes("/.bun/") || "bun" in process.versions) {
+            return "bun";
+        }
+        // Check if running under pnpm
+        if (execPath.includes("/pnpm/") || execPath.includes("/.pnpm/")) {
+            return "pnpm";
+        }
+        // Check if running under yarn
+        if (execPath.includes("/yarn/") || execPath.includes("/.yarn/")) {
+            return "yarn";
+        }
+    }
+    catch {
+        // ignore detection errors
+    }
+    return "npm";
+}
+function getInstallCommand(pm) {
+    switch (pm) {
+        case "bun":
+            return `bun install -g ${PACKAGE_NAME}@latest`;
+        case "pnpm":
+            return `pnpm add -g ${PACKAGE_NAME}@latest`;
+        case "yarn":
+            return `yarn global add ${PACKAGE_NAME}@latest`;
+        default:
+            return `npm install -g ${PACKAGE_NAME}@latest`;
+    }
+}
+export async function updateCommand(opts) {
+    const current = getCurrentVersion();
+    const spin = output.spinner("Checking for updates...");
+    let latest;
+    try {
+        latest = await fetchLatestVersion();
+    }
+    catch (err) {
+        spin.fail();
+        output.error(err.message);
+        process.exit(1);
+    }
+    const cmp = compareSemver(current, latest);
+    if (cmp === 0) {
+        spin.succeed(`Already on the latest version (${current})`);
+        return;
+    }
+    if (cmp > 0) {
+        spin.succeed(`You're ahead of latest (${current} > ${latest}). No update needed.`);
+        return;
+    }
+    spin.succeed(`Update available: ${current} → ${latest}`);
+    if (opts.check) {
+        return;
+    }
+    const pm = detectPackageManager();
+    const cmd = getInstallCommand(pm);
+    output.blank();
+    output.info(`Updating via ${pm}...`);
+    output.dim(`  $ ${cmd}`);
+    output.blank();
+    try {
+        execSync(cmd, { stdio: "inherit" });
+        output.blank();
+        output.success(`Updated to ${PACKAGE_NAME}@${latest}`);
+    }
+    catch {
+        output.blank();
+        output.error("Update failed. Try running manually:");
+        output.dim(`  $ ${cmd}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=update.js.map

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