agentspend 0.1.10 → 0.2.0

package/dist/commands/pay.js

@@ -1,227 +1,110 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerPayCommand = registerPayCommand;
-const promises_1 = require("node:fs/promises");
-const node_os_1 = require("node:os");
-const node_path_1 = require("node:path");
-const CONFIG_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".agentspend");
-const CARD_FILE = (0, node_path_1.join)(CONFIG_DIR, "card.json");
-const WALLET_FILE = (0, node_path_1.join)(CONFIG_DIR, "wallet.json");
-const API_BASE = process.env.AGENTSPEND_API_URL ?? "https://api.agentspend.co";
-async function readCardConfig() {
-    try {
-        const data = JSON.parse(await (0, promises_1.readFile)(CARD_FILE, "utf-8"));
-        if (typeof data.card_id === "string" && data.card_id && typeof data.card_secret === "string" && data.card_secret) {
-            return data;
-        }
-    }
-    catch {
-        // file doesn't exist or is invalid
-    }
-    return null;
+import { ApiError } from "../lib/api.js";
+import { requireApiKey } from "../lib/credentials.js";
+import { formatJson, formatUsd, formatUsdEstimate, usd6ToUsd } from "../lib/output.js";
+import { normalizeMethod, parseBody, parseHeaders } from "../lib/request-options.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
 }
-async function readWalletConfig() {
-    try {
-        const data = JSON.parse(await (0, promises_1.readFile)(WALLET_FILE, "utf-8"));
-        if (typeof data.address === "string" && data.address) {
-            return data;
-        }
-    }
-    catch {
-        // file doesn't exist or is invalid
-    }
-    return null;
+function readNumber(record, key) {
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
-function parseHeaders(headerArgs) {
-    const headers = {};
-    for (const h of headerArgs) {
-        const idx = h.indexOf(":");
-        if (idx === -1) {
-            throw new Error(`Invalid header format: "${h}". Use key:value`);
-        }
-        headers[h.slice(0, idx).trim()] = h.slice(idx + 1).trim();
-    }
-    return headers;
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
 }
-async function payWithCard(url, cardConfig, body, extraHeaders) {
-    const headers = {
-        ...extraHeaders,
-        "x-card-id": cardConfig.card_id,
-    };
-    if (body) {
-        headers["content-type"] = "application/json";
-    }
-    // Try with x-card-id
-    const res = await fetch(url, {
-        method: "POST",
-        headers,
-        body: body ?? undefined,
-    });
-    // Success
-    if (res.ok) {
-        console.log("Payment successful (card)");
-        const data = await res.text();
-        try {
-            console.log(JSON.stringify(JSON.parse(data), null, 2));
-        }
-        catch {
-            console.log(data);
-        }
-        return;
+function parsePayErrorCode(value) {
+    if (typeof value !== "string") {
+        return undefined;
     }
-    // 402 with agentspend.service_id — need to bind
-    if (res.status === 402) {
-        const errorBody = await res.json().catch(() => ({}));
-        const agentspend = errorBody?.agentspend;
-        const serviceId = agentspend?.service_id;
-        if (serviceId) {
-            console.log(`Binding to service ${serviceId}...`);
-            const bindRes = await fetch(`${API_BASE}/v1/card/${encodeURIComponent(cardConfig.card_id)}/bind`, {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({
-                    card_secret: cardConfig.card_secret,
-                    service_id: serviceId,
-                }),
-            });
-            if (!bindRes.ok) {
-                const bindError = await bindRes.text();
-                console.error(`Failed to bind (${bindRes.status}): ${bindError}`);
-                process.exit(1);
-            }
-            console.log("Bound. Retrying payment...");
-            // Retry with x-card-id
-            const retryRes = await fetch(url, { method: "POST", headers, body: body ?? undefined });
-            if (!retryRes.ok) {
-                console.error(`Retry failed (${retryRes.status}): ${await retryRes.text()}`);
-                process.exit(1);
-            }
-            console.log("Payment successful (card)");
-            const data = await retryRes.text();
-            try {
-                console.log(JSON.stringify(JSON.parse(data), null, 2));
-            }
-            catch {
-                console.log(data);
-            }
-            return;
-        }
+    if (value === "PRICE_EXCEEDS_MAX" ||
+        value === "PRICE_NOT_CONVERTIBLE" ||
+        value === "WEEKLY_BUDGET_EXCEEDED" ||
+        value === "DOMAIN_NOT_ALLOWLISTED") {
+        return value;
     }
-    // Other error
-    console.error(`Request failed (${res.status}): ${await res.text().catch(() => "")}`);
-    process.exit(1);
+    return undefined;
 }
-async function payWithCrypto(url, walletConfig, body, extraHeaders) {
-    const headers = { ...extraHeaders };
-    if (body) {
-        headers["content-type"] = "application/json";
-    }
-    // First request — expect 402
-    const initialRes = await fetch(url, {
-        method: "POST",
-        headers,
-        body: body ?? undefined,
-    });
-    if (initialRes.status !== 402) {
-        if (initialRes.ok) {
-            console.log("Request succeeded without payment.");
-            const data = await initialRes.text();
-            try {
-                console.log(JSON.stringify(JSON.parse(data), null, 2));
-            }
-            catch {
-                console.log(data);
-            }
-            return;
-        }
-        const data = await initialRes.text();
-        console.error(`Expected 402 but got ${initialRes.status}: ${data}`);
-        process.exit(1);
+function parsePayErrorBody(body) {
+    if (!isRecord(body)) {
+        return {};
     }
-    // Import x402 and viem dynamically
-    const { x402Client } = await import("@x402/core/client");
-    const { x402HTTPClient } = await import("@x402/core/http");
-    const { registerExactEvmScheme } = await import("@x402/evm/exact/client");
-    const { privateKeyToAccount } = await import("viem/accounts");
-    const account = privateKeyToAccount(walletConfig.private_key);
-    const coreClient = new x402Client();
-    registerExactEvmScheme(coreClient, { signer: account });
-    const httpClient = new x402HTTPClient(coreClient);
-    // Decode payment requirements from 402 response
-    const paymentRequired = httpClient.getPaymentRequiredResponse((name) => initialRes.headers.get(name), await initialRes.clone().json().catch(() => undefined));
-    // Sign payment
-    const paymentPayload = await httpClient.createPaymentPayload(paymentRequired);
-    const paymentHeaders = httpClient.encodePaymentSignatureHeader(paymentPayload);
-    // Resend with payment header
-    const paidRes = await fetch(url, {
-        method: "POST",
-        headers: { ...headers, ...paymentHeaders },
-        body: body ?? undefined,
-    });
-    const data = await paidRes.text();
-    if (!paidRes.ok) {
-        console.error(`Paid request failed (${paidRes.status}): ${data}`);
-        process.exit(1);
+    const parsed = {
+        code: parsePayErrorCode(body.code),
+    };
+    if (!isRecord(body.details)) {
+        return parsed;
     }
-    console.log("Payment successful (crypto)");
+    const detailsRecord = body.details;
+    parsed.details = {
+        offered_price_usd6: readNumber(detailsRecord, "offered_price_usd6"),
+        offered_price_usd: readNumber(detailsRecord, "offered_price_usd"),
+        max_cost_usd6: readNumber(detailsRecord, "max_cost_usd6"),
+        max_cost_usd: readNumber(detailsRecord, "max_cost_usd"),
+        weekly_limit_usd6: readNumber(detailsRecord, "weekly_limit_usd6"),
+        weekly_limit_usd: readNumber(detailsRecord, "weekly_limit_usd"),
+        spent_this_week_usd6: readNumber(detailsRecord, "spent_this_week_usd6"),
+        spent_this_week_usd: readNumber(detailsRecord, "spent_this_week_usd"),
+        attempted_charge_usd6: readNumber(detailsRecord, "attempted_charge_usd6"),
+        attempted_charge_usd: readNumber(detailsRecord, "attempted_charge_usd"),
+        estimated_usd: readNumber(detailsRecord, "estimated_usd"),
+        amount_display: readString(detailsRecord, "amount_display"),
+        currency: readString(detailsRecord, "currency"),
+    };
+    return parsed;
+}
+export async function runPay(apiClient, url, options) {
+    const apiKey = await requireApiKey();
+    const method = normalizeMethod(options.method);
     try {
-        console.log(JSON.stringify(JSON.parse(data), null, 2));
-    }
-    catch {
-        console.log(data);
+        const response = await apiClient.pay(apiKey, {
+            url,
+            method,
+            headers: parseHeaders(options.header),
+            body: parseBody(options.body),
+            max_cost_usd: options.maxCost,
+        });
+        console.log(formatJson(response.body));
+        if (response.payment) {
+            console.log(`\nCharged: ${formatUsd(response.payment.charged_usd)} | Remaining: ${formatUsd(response.payment.remaining_budget_usd)}`);
+        }
     }
-}
-function registerPayCommand(program) {
-    program
-        .command("pay")
-        .description("Pay a paywall-protected endpoint using card or crypto wallet")
-        .argument("<url>", "URL of the paywall-protected endpoint")
-        .option("--method <method>", "Payment method: card or crypto (default: auto-detect)")
-        .option("--body <json>", "Request body JSON")
-        .option("--header <key:value>", "Extra headers (repeatable)", (val, prev) => {
-        prev.push(val);
-        return prev;
-    }, [])
-        .action(async (url, opts) => {
-        try {
-            const extraHeaders = parseHeaders(opts.header);
-            if (opts.method === "card") {
-                const card = await readCardConfig();
-                if (!card) {
-                    console.error("No card configured. Run: agentspend card setup");
-                    process.exit(1);
+    catch (error) {
+        if (error instanceof ApiError) {
+            const body = parsePayErrorBody(error.body);
+            if (error.status === 400 && body.code === "PRICE_EXCEEDS_MAX") {
+                const offered = body.details?.offered_price_usd ??
+                    (typeof body.details?.offered_price_usd6 === "number" ? usd6ToUsd(body.details.offered_price_usd6) : 0);
+                const max = body.details?.max_cost_usd ??
+                    (typeof body.details?.max_cost_usd6 === "number" ? usd6ToUsd(body.details.max_cost_usd6) : 0);
+                const estimatedUsd = body.details?.estimated_usd;
+                const amountDisplay = body.details?.amount_display;
+                const currency = body.details?.currency ?? "USDC";
+                console.error(`Price ${formatUsd(offered)} exceeds --max-cost ${formatUsd(max)}. Run without --max-cost or increase it.`);
+                if (amountDisplay) {
+                    console.error(`Offered token amount: ${amountDisplay} ${currency} (~${formatUsdEstimate(estimatedUsd, offered)})`);
                 }
-                await payWithCard(url, card, opts.body, extraHeaders);
                 return;
             }
-            if (opts.method === "crypto") {
-                const wallet = await readWalletConfig();
-                if (!wallet) {
-                    console.error("No wallet configured. Run: agentspend wallet create");
-                    process.exit(1);
-                }
-                await payWithCrypto(url, wallet, opts.body, extraHeaders);
+            if (error.status === 400 && body.code === "PRICE_NOT_CONVERTIBLE") {
+                console.error("Price could not be converted to 6-decimal USD units for policy checks.");
                 return;
             }
-            // Auto-detect: try card first, then crypto
-            const card = await readCardConfig();
-            if (card) {
-                await payWithCard(url, card, opts.body, extraHeaders);
+            if (error.status === 402 && body.code === "WEEKLY_BUDGET_EXCEEDED") {
+                const weeklyLimit = body.details?.weekly_limit_usd ??
+                    (typeof body.details?.weekly_limit_usd6 === "number" ? usd6ToUsd(body.details.weekly_limit_usd6) : 0);
+                const spent = body.details?.spent_this_week_usd ??
+                    (typeof body.details?.spent_this_week_usd6 === "number" ? usd6ToUsd(body.details.spent_this_week_usd6) : 0);
+                const attempted = body.details?.attempted_charge_usd ??
+                    (typeof body.details?.attempted_charge_usd6 === "number" ? usd6ToUsd(body.details.attempted_charge_usd6) : 0);
+                console.error(`Weekly budget exceeded. Limit ${formatUsd(weeklyLimit)}, spent ${formatUsd(spent)}, attempted ${formatUsd(attempted)}.`);
                 return;
             }
-            const wallet = await readWalletConfig();
-            if (wallet) {
-                await payWithCrypto(url, wallet, opts.body, extraHeaders);
+            if (error.status === 403 && body.code === "DOMAIN_NOT_ALLOWLISTED") {
+                console.error("This domain is not in your AgentSpend allowlist.");
                 return;
             }
-            console.error("No payment method configured.");
-            console.error("Set up a card:   agentspend card setup");
-            console.error("Or create a wallet: agentspend wallet create");
-            process.exit(1);
         }
-        catch (err) {
-            console.error(`Error: ${err instanceof Error ? err.message : err}`);
-            process.exit(1);
-        }
-    });
+        throw error;
+    }
 }

package/dist/commands/search.js

@@ -0,0 +1,16 @@
+import { requireApiKey } from "../lib/credentials.js";
+export async function runSearch(apiClient, query) {
+    const apiKey = await requireApiKey();
+    const response = await apiClient.search(apiKey, query);
+    if (response.services.length === 0) {
+        console.log(`No services matched "${response.query}".`);
+        return;
+    }
+    for (const service of response.services) {
+        console.log(service.name);
+        console.log(`Description: ${service.description}`);
+        console.log(`Domain: ${service.domain}`);
+        console.log(`Skill URL: ${service.skill_url ?? "n/a"}`);
+        console.log("");
+    }
+}

package/dist/commands/setup.js

@@ -0,0 +1,36 @@
+import bcrypt from "bcryptjs";
+import crypto from "node:crypto";
+import { saveCredentials } from "../lib/credentials.js";
+const POLL_INTERVAL_MS = 2_000;
+const SETUP_TIMEOUT_MS = 10 * 60 * 1000;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function generateApiKey() {
+    return `sk_agent_${crypto.randomBytes(32).toString("hex")}`;
+}
+export async function runSetup(apiClient) {
+    const setup = await apiClient.createSetup();
+    console.log(`Open this URL to complete setup:\n${setup.setup_url}\n`);
+    console.log("Waiting for setup to complete...");
+    const started = Date.now();
+    while (Date.now() - started < SETUP_TIMEOUT_MS) {
+        const status = await apiClient.getSetupStatus(setup.setup_id);
+        if (status.status === "ready") {
+            const apiKey = generateApiKey();
+            const apiKeyHash = await bcrypt.hash(apiKey, 12);
+            await apiClient.claimSetup(setup.setup_id, apiKeyHash);
+            await saveCredentials(apiKey);
+            console.log("Ready! Your agent can now spend.");
+            return;
+        }
+        if (status.status === "claimed") {
+            throw new Error("This setup session was already claimed. Run agentspend setup again.");
+        }
+        if (status.status === "expired") {
+            throw new Error("Setup timed out. Run agentspend setup again.");
+        }
+        await sleep(POLL_INTERVAL_MS);
+    }
+    throw new Error("Setup timed out. Run agentspend setup again.");
+}

package/dist/commands/status.js

@@ -0,0 +1,7 @@
+import { requireApiKey } from "../lib/credentials.js";
+import { printStatus } from "../lib/output.js";
+export async function runStatus(apiClient) {
+    const apiKey = await requireApiKey();
+    const status = await apiClient.status(apiKey);
+    printStatus(status);
+}

package/dist/dev-index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { runCli } from "./cli.js";
+const LOCAL_API_BASE_URL = "http://127.0.0.1:8787";
+runCli({
+    baseUrl: LOCAL_API_BASE_URL,
+    programName: "agentspend-dev",
+}).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/index.js

@@ -1,16 +1,6 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const card_js_1 = require("./commands/card.js");
-const wallet_js_1 = require("./commands/wallet.js");
-const pay_js_1 = require("./commands/pay.js");
-const program = new commander_1.Command();
-program
-    .name("agentspend")
-    .description("AgentSpend CLI — manage cards and billing")
-    .version("0.1.0");
-(0, card_js_1.registerCardCommands)(program);
-(0, wallet_js_1.registerWalletCommands)(program);
-(0, pay_js_1.registerPayCommand)(program);
-program.parse();
+import { runCli } from "./cli.js";
+runCli().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/lib/api.js

@@ -0,0 +1,98 @@
+const API_URL = "https://api.agentspend.co";
+export class ApiError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.name = "ApiError";
+        this.status = status;
+        this.body = body;
+    }
+}
+async function parseBody(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+        try {
+            return await response.json();
+        }
+        catch {
+            return null;
+        }
+    }
+    return response.text();
+}
+function errorMessageFromBody(body, fallback) {
+    if (body && typeof body === "object" && "error" in body && typeof body.error === "string") {
+        return body.error;
+    }
+    if (typeof body === "string" && body.length > 0) {
+        return body;
+    }
+    return fallback;
+}
+export class AgentspendApiClient {
+    baseUrl;
+    constructor(baseUrl = API_URL) {
+        this.baseUrl = baseUrl;
+    }
+    async request(path, init = {}, apiKey) {
+        const headers = {
+            ...init.headers,
+        };
+        if (apiKey) {
+            headers.Authorization = `Bearer ${apiKey}`;
+        }
+        if (init.body && !headers["content-type"] && !headers["Content-Type"]) {
+            headers["content-type"] = "application/json";
+        }
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            ...init,
+            headers,
+        });
+        const body = await parseBody(response);
+        if (!response.ok) {
+            throw new ApiError(errorMessageFromBody(body, `Request failed (${response.status})`), response.status, body);
+        }
+        return body;
+    }
+    pay(apiKey, payload) {
+        return this.request("/pay", {
+            method: "POST",
+            body: JSON.stringify(payload),
+        }, apiKey);
+    }
+    check(apiKey, payload) {
+        return this.request("/check", {
+            method: "POST",
+            body: JSON.stringify(payload),
+        }, apiKey);
+    }
+    status(apiKey) {
+        return this.request("/status", {
+            method: "GET",
+        }, apiKey);
+    }
+    configure(payload, apiKey) {
+        return this.request("/configure", {
+            method: "POST",
+            body: payload ? JSON.stringify(payload) : undefined,
+        }, apiKey);
+    }
+    configureStatus(token) {
+        return this.request(`/configure/${encodeURIComponent(token)}/status`, {
+            method: "GET",
+        });
+    }
+    claimConfigure(token, apiKeyHash) {
+        return this.request(`/configure/${encodeURIComponent(token)}/claim`, {
+            method: "POST",
+            body: JSON.stringify({ api_key_hash: apiKeyHash }),
+        });
+    }
+    search(apiKey, query) {
+        const params = new URLSearchParams({ q: query });
+        return this.request(`/search?${params.toString()}`, {
+            method: "GET",
+        }, apiKey);
+    }
+}

package/dist/lib/credentials.js

@@ -0,0 +1,65 @@
+import { mkdir, readFile, writeFile, chmod, unlink } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const CREDENTIALS_DIR = path.join(os.homedir(), ".agentspend");
+const CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
+const PENDING_CONFIGURE_FILE = path.join(CREDENTIALS_DIR, "pending-configure.json");
+export async function readCredentials() {
+    try {
+        const raw = await readFile(CREDENTIALS_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed.api_key || !parsed.api_key.startsWith("sk_agent_")) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveCredentials(apiKey) {
+    const payload = {
+        api_key: apiKey,
+        created_at: new Date().toISOString(),
+    };
+    await mkdir(CREDENTIALS_DIR, { recursive: true, mode: 0o700 });
+    await writeFile(CREDENTIALS_FILE, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+    try {
+        await chmod(CREDENTIALS_FILE, 0o600);
+    }
+    catch {
+        // no-op when chmod is not available on the host filesystem
+    }
+}
+export async function requireApiKey() {
+    const credentials = await readCredentials();
+    if (!credentials) {
+        throw new Error(`No API key found at ${CREDENTIALS_FILE}. Run \`agentspend configure\` first.`);
+    }
+    return credentials.api_key;
+}
+export async function readPendingConfigureToken() {
+    try {
+        const raw = await readFile(PENDING_CONFIGURE_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed.token || !parsed.token.startsWith("cfs_")) {
+            return null;
+        }
+        return parsed.token;
+    }
+    catch {
+        return null;
+    }
+}
+export async function savePendingConfigureToken(token) {
+    await mkdir(CREDENTIALS_DIR, { recursive: true, mode: 0o700 });
+    await writeFile(PENDING_CONFIGURE_FILE, `${JSON.stringify({ token, created_at: new Date().toISOString() }, null, 2)}\n`, "utf-8");
+}
+export async function clearPendingConfigureToken() {
+    try {
+        await unlink(PENDING_CONFIGURE_FILE);
+    }
+    catch {
+        // no-op
+    }
+}

package/dist/lib/output.js

@@ -0,0 +1,76 @@
+const USD6_SCALE = 1_000_000;
+function formatUsdNumber(value, minDecimals = 2, maxDecimals = 6) {
+    const fixed = value.toFixed(maxDecimals);
+    const trimmed = fixed.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
+    if (!trimmed.includes(".")) {
+        return minDecimals > 0 ? `${trimmed}.${"0".repeat(minDecimals)}` : trimmed;
+    }
+    const [whole, frac = ""] = trimmed.split(".");
+    if (frac.length >= minDecimals) {
+        return trimmed;
+    }
+    return `${whole}.${frac.padEnd(minDecimals, "0")}`;
+}
+export function usd6ToUsd(usd6) {
+    return usd6 / USD6_SCALE;
+}
+export function formatUsd(usd) {
+    if (!Number.isFinite(usd)) {
+        return "unknown";
+    }
+    return `$${formatUsdNumber(usd, 2, 6)}`;
+}
+export function formatUsdEstimate(estimatedUsd, fallbackUsd) {
+    if (typeof estimatedUsd === "number") {
+        return formatUsd(estimatedUsd);
+    }
+    if (typeof fallbackUsd === "number") {
+        return formatUsd(fallbackUsd);
+    }
+    return "unknown";
+}
+export function formatJson(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return JSON.stringify(value, null, 2);
+}
+export function relativeTime(iso) {
+    const timestamp = new Date(iso).getTime();
+    const diffMs = Date.now() - timestamp;
+    const abs = Math.max(0, Math.floor(diffMs / 1000));
+    if (abs < 60) {
+        return `${abs}s ago`;
+    }
+    const minutes = Math.floor(abs / 60);
+    if (minutes < 60) {
+        return `${minutes}m ago`;
+    }
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24) {
+        return `${hours}h ago`;
+    }
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+function formatCharge(charge) {
+    const amountUsd = charge.amount_usd ?? usd6ToUsd(charge.amount_usd6);
+    const amount = formatUsd(amountUsd).padEnd(10);
+    const domain = charge.target_domain.padEnd(24);
+    const when = relativeTime(charge.created_at);
+    return `  ${amount} ${domain} ${when}`;
+}
+export function printStatus(status) {
+    console.log(`Weekly budget:   ${formatUsd(status.weekly_budget_usd)}`);
+    console.log(`Spent this week: ${formatUsd(status.spent_this_week_usd)}`);
+    console.log(`Remaining:       ${formatUsd(status.remaining_budget_usd)}`);
+    console.log("");
+    if (status.recent_charges.length === 0) {
+        console.log("Recent charges: none");
+        return;
+    }
+    console.log("Recent charges:");
+    for (const charge of status.recent_charges) {
+        console.log(formatCharge(charge));
+    }
+}