spendctl 0.0.0-stage → 0.2.0

package/bin/spendctl.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// node:sqlite is used for the ledger; hide its one-line ExperimentalWarning on Node 22.
+const emit = process.emitWarning.bind(process);
+process.emitWarning = (warning, ...rest) => {
+  const text = typeof warning === "string" ? warning : (warning?.message ?? "");
+  if (text.includes("SQLite is an experimental feature")) return;
+  return emit(warning, ...rest);
+};
+const { main } = await import("../dist/index.js");
+process.exitCode = await main(process.argv.slice(2));

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export declare const VERSION = "0.2.0";
+type Flags = Record<string, string | boolean | string[] | undefined>;
+export declare function main(argv: string[]): Promise<number>;
+export type { Flags };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA0CA,eAAO,MAAM,OAAO,UAAU,CAAC;AAwC/B,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;AAmmBrE,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA2B1D;AAED,YAAY,EAAE,KAAK,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,653 @@
+import { spawn } from "node:child_process";
+import { appendFileSync, existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { AdminClient, readRefusal, wrapFetch } from "@spendctl/client";
+import { ConfigError, checkPlan, formatUsd, isSandbox, Ledger, LICENSE_GRACE_MS, LicenseError, loadConfig, newToken, PlanError, PRICING_URL, parseLicenseKey, planLine, planUsage, TIER_LABELS, } from "@spendctl/core";
+import { createSigner, listen, requestTestnetUsdc, Sidecar } from "@spendctl/proxy";
+import { ensureAdminToken, loadDotenv, loadPlan, paths, readAdminToken, readAgentTokens, removeLicenseKey, sidecarUrl, tryLoadConfig, writeAgentTokens, writeLicenseKey, } from "./state.js";
+import { ENV_EXAMPLE, policyTemplate } from "./templates.js";
+import { c, short, statusColor, table } from "./ui.js";
+export const VERSION = "0.2.0";
+const HELP = `${c.bold("spendctl")} ${VERSION} — budgets, approvals and receipts for AI agents that pay (x402, MPP)
+
+${c.bold("Usage")}
+  spendctl <command> [options]
+
+${c.bold("Setup")}
+  init [--signer mock|cdp|private-key] [--force]   Create spendctl.yaml and .spendctl/
+  start [--dry-run] [--port N]                     Run the sidecar (agents send requests here)
+  mock                                             Run a mock facilitator + two paid APIs (ports 4020-4022)
+
+${c.bold("Agents")}
+  fetch <url> [--agent A] [-X METHOD] [-d BODY] [-H 'K: V'] [--dry-run]
+                                                   Make a request through the sidecar as an agent
+  run --agent A -- <command...>                    Run a command with HTTP_PROXY pointing at the sidecar
+  mcp                                              Serve the MCP tools pay / check_budget / list_receipts (stdio)
+  token <agent>                                    Create a per-agent token (for agentAuth: token)
+
+${c.bold("Humans")}
+  pending                                          List payments waiting for approval
+  approve <id> | --latest | --all [--note TEXT]     Approve
+  deny <id> | --latest [--note TEXT]               Deny
+  budget [--agent A]                               Show budgets and what is left
+  ledger [--agent A] [--limit N]                   Show recent payment decisions
+  export [--format csv|json] [--out FILE] [--agent A] [--since ISO]
+                                                   Export receipts for expense reports
+  trace <attempt-id>                               Show an agent→agent payment chain
+  resolve <attempt-id> --settled|--failed [--tx HASH]
+                                                   Reconcile an attempt whose outcome was unknown
+  dashboard [--open]                               Print (or open) the local dashboard URL
+  wallet [address|fund]                            Show the signer address / request testnet USDC (CDP)
+  license [set <key> | remove]                     Show the plan and this month's usage / store or remove a licence key
+
+${c.bold("Global options")}
+  -c, --config FILE   Policy file (default ./spendctl.yaml or $SPENDCTL_CONFIG)
+  -h, --help          Show help
+  -v, --version       Show version
+`;
+function parse(argv, options = {}) {
+    const result = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        strict: true,
+        options: {
+            config: { type: "string", short: "c" },
+            help: { type: "boolean", short: "h" },
+            ...options,
+        },
+    });
+    return { values: result.values, positionals: result.positionals };
+}
+function out(text = "") {
+    process.stdout.write(`${text}\n`);
+}
+function err(text) {
+    process.stderr.write(`${text}\n`);
+}
+function admin(p) {
+    return new AdminClient({ url: sidecarUrl(p), token: readAdminToken(p) });
+}
+/** Inside the 30-day grace window the paid limits still apply; say so once a day (docs/PLANS.md). */
+function expiryWarning(plan, now = Date.now()) {
+    if (plan.expiresAt === undefined || plan.expiresAt - now > LICENSE_GRACE_MS)
+        return undefined;
+    const days = Math.max(0, Math.ceil((plan.expiresAt - now) / 86_400_000));
+    const date = new Date(plan.expiresAt).toISOString().slice(0, 10);
+    return `licence key expires in ${days} day${days === 1 ? "" : "s"} (${date}); after that the sidecar runs with the Free limits. Renew: ${PRICING_URL}`;
+}
+/** This month's usage: from the running sidecar when there is one, else straight from the ledger. */
+async function usageFor(p, plan) {
+    try {
+        const live = (await admin(p).summary()).plan;
+        if (live)
+            return live;
+    }
+    catch {
+        // no sidecar running (or no admin token yet): read the ledger directly
+    }
+    const config = tryLoadConfig(p);
+    const ledger = await Ledger.open(resolve(p.root, config?.ledger.path ?? ".spendctl/ledger.db"));
+    try {
+        return planUsage(plan, ledger, { sandbox: config ? isSandbox(config) : false });
+    }
+    finally {
+        ledger.close();
+    }
+}
+function eventLine(event) {
+    const a = event.attempt;
+    const time = new Date().toTimeString().slice(0, 8);
+    if (event.type === "approval" && event.approval) {
+        const amount = event.approval.usdMicros !== undefined ? formatUsd(BigInt(event.approval.usdMicros)) : "";
+        return `${c.yellow("⏸")} ${c.gray(time)} ${event.approval.agent}  ${a?.method ?? ""} ${event.approval.host}${event.approval.path}  ${c.bold(amount)}  ${c.yellow("needs approval")} ${c.bold(event.approval.id)}\n   ${c.dim(event.approval.reasons.map((r) => r.message).join(" "))}\n   ${c.dim("→ run:")} spendctl approve ${event.approval.id}`;
+    }
+    if (!a) {
+        if (event.type === "plan")
+            return `${c.yellow("!")} ${c.gray(time)} ${event.message}`;
+        return event.type === "error" ? `${c.red("!")} ${c.gray(time)} ${event.message}` : undefined;
+    }
+    const amount = a.usdMicros !== undefined ? formatUsd(a.usdMicros) : "-";
+    const where = `${a.method} ${a.host}${a.path}`;
+    if (event.type === "settled") {
+        return `${c.green("✔")} ${c.gray(time)} ${a.agent}  ${where}  ${c.bold(amount)}  ${statusColor("settled")}  ${c.gray(short(a.txHash, 14))}`;
+    }
+    if (event.type === "failed") {
+        return `${c.red("✖")} ${c.gray(time)} ${a.agent}  ${where}  ${amount}  ${statusColor(a.status)}  ${c.dim(a.error ?? "")}`;
+    }
+    if (event.type === "decision" && (a.status === "denied" || a.status === "dry_run")) {
+        const icon = a.status === "dry_run" ? c.yellow("○") : c.red("✖");
+        return `${icon} ${c.gray(time)} ${a.agent}  ${where}  ${amount}  ${statusColor(a.status)}  ${c.dim(a.reasons[0]?.message ?? "")}`;
+    }
+    if (event.type === "decision" && a.status === "expired") {
+        // A held request that ended without a payment: the requester left, or holdMax passed.
+        return `${c.yellow("⏸")} ${c.gray(time)} ${a.agent}  ${where}  ${amount}  ${statusColor("expired")}  ${c.dim(event.message.replace(`${a.id} `, ""))}`;
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------- commands
+async function cmdInit(argv) {
+    const { values } = parse(argv, { signer: { type: "string" }, force: { type: "boolean" } });
+    const p = paths(values.config);
+    const signer = (values.signer ?? "mock");
+    if (!["mock", "cdp", "private-key"].includes(signer)) {
+        err(`Unknown signer "${signer}" (use mock, cdp or private-key)`);
+        return 1;
+    }
+    if (existsSync(p.config) && !values.force) {
+        err(`${relative(process.cwd(), p.config) || p.config} already exists (use --force to overwrite).`);
+        return 1;
+    }
+    writeFileSync(p.config, policyTemplate(signer));
+    ensureAdminToken(p);
+    const gitignore = resolve(p.root, ".gitignore");
+    const lines = existsSync(gitignore) ? readFileSync(gitignore, "utf8") : "";
+    const missing = [".spendctl/", ".env"].filter((entry) => !lines.split(/\r?\n/).includes(entry));
+    if (missing.length)
+        appendFileSync(gitignore, `${lines && !lines.endsWith("\n") ? "\n" : ""}${missing.join("\n")}\n`);
+    if (signer !== "mock" && !existsSync(resolve(p.root, ".env.example")))
+        writeFileSync(resolve(p.root, ".env.example"), ENV_EXAMPLE);
+    out(`${c.green("✔")} wrote ${relative(process.cwd(), p.config) || "spendctl.yaml"} (signer: ${signer})`);
+    out(`${c.green("✔")} created .spendctl/ (admin token, ledger) — git-ignored`);
+    out("");
+    out(c.bold("Next:"));
+    if (signer === "mock") {
+        out(`  1. ${c.cyan("npx spendctl mock")}        # terminal 1: mock facilitator + paid APIs`);
+        out(`  2. ${c.cyan("npx spendctl start")}       # terminal 2: the sidecar`);
+        out(`  3. ${c.cyan("npx spendctl fetch http://localhost:4021/weather --agent researcher")}`);
+    }
+    else {
+        out(`  1. Fill in .env (see .env.example)`);
+        out(`  2. ${c.cyan("npx spendctl wallet fund")}  # testnet USDC from the CDP faucet`);
+        out(`  3. ${c.cyan("npx spendctl start")}`);
+    }
+    return 0;
+}
+async function cmdStart(argv) {
+    const { values } = parse(argv, {
+        "dry-run": { type: "boolean" },
+        port: { type: "string" },
+        host: { type: "string" },
+    });
+    const p = paths(values.config);
+    loadDotenv(p.root);
+    const config = loadConfig(p.config);
+    if (values.port)
+        config.server.port = Number(values.port);
+    if (values.host)
+        config.server.host = String(values.host);
+    const license = loadPlan(p);
+    if (license.warning)
+        err(`${c.yellow("!")} ${license.warning}`);
+    try {
+        checkPlan(config, license.plan);
+    }
+    catch (error) {
+        if (!(error instanceof PlanError))
+            throw error;
+        err(c.red(error.message));
+        return 1;
+    }
+    const adminToken = ensureAdminToken(p);
+    const signer = await createSigner(config.signer);
+    const ledgerPath = resolve(p.root, config.ledger.path);
+    const ledger = await Ledger.open(ledgerPath);
+    const sidecar = new Sidecar({
+        config,
+        ledger,
+        evmSigner: signer.signer,
+        adminToken,
+        agentTokens: readAgentTokens(p),
+        dryRun: Boolean(values["dry-run"]),
+        plan: license.plan,
+        onEvent: (event) => {
+            const line = eventLine(event);
+            if (line)
+                out(line);
+        },
+    });
+    const running = await listen(sidecar);
+    writeFileSync(p.sidecar, `${JSON.stringify({ url: running.url, pid: process.pid, startedAt: new Date().toISOString() })}\n`);
+    const agents = Object.keys(config.agents);
+    out(`${c.bold("spendctl")} ${VERSION} listening on ${c.cyan(running.url)}${values["dry-run"] ? c.yellow("  [DRY RUN — nothing will be paid]") : ""}`);
+    out(`${c.dim("signer ")} ${signer.kind} · ${signer.address} ${c.dim(`(${signer.description})`)}`);
+    out(`${c.dim("policy ")} ${relative(process.cwd(), p.config) || p.config} · ${agents.length} agent(s): ${agents.join(", ")}`);
+    out(`${c.dim("ledger ")} ${relative(process.cwd(), ledgerPath) || ledgerPath}`);
+    out(`${c.dim("plan   ")} ${planLine(sidecar.usage())}`);
+    out(`${c.dim("agents ")} send requests to ${running.url}/<absolute-url> with header X-Spendctl-Agent`);
+    const warnExpiry = () => {
+        const warning = expiryWarning(license.plan);
+        if (warning)
+            err(`${c.yellow("!")} ${warning}`);
+    };
+    warnExpiry();
+    setInterval(warnExpiry, 86_400_000).unref();
+    const stop = async () => {
+        await running.close();
+        ledger.close();
+        rmSync(p.sidecar, { force: true });
+        process.exit(0);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    setInterval(() => sidecar.broker.expireStale(), 5_000).unref();
+    await new Promise(() => undefined);
+    return 0;
+}
+async function cmdMock(argv) {
+    const { values } = parse(argv, { base: { type: "string" } });
+    const { startDemoServers } = await import("@spendctl/mock");
+    const base = Number(values.base ?? 4020);
+    const servers = await startDemoServers({ facilitator: base, weather: base + 1, search: base + 2 });
+    out(`${c.bold("spendctl mock")} — nothing here touches a real chain`);
+    out(`${c.dim("facilitator")} ${servers.facilitator.url}  (verifies EIP-3009 signatures, fake settlement)`);
+    out(`${c.dim("weather    ")} http://localhost:${servers.weather.port}/weather?city=Tokyo   $0.01  x402 v2`);
+    out(`${c.dim("search     ")} http://localhost:${servers.search.port}/search?q=x402       $0.02  x402 v1`);
+    const stop = async () => {
+        await servers.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    await new Promise(() => undefined);
+    return 0;
+}
+async function cmdFetch(argv) {
+    const { values, positionals } = parse(argv, {
+        agent: { type: "string", short: "a" },
+        method: { type: "string", short: "X" },
+        data: { type: "string", short: "d" },
+        header: { type: "string", short: "H", multiple: true },
+        "dry-run": { type: "boolean" },
+        quiet: { type: "boolean", short: "q" },
+    });
+    const url = positionals[0];
+    if (!url) {
+        err("Usage: spendctl fetch <url> [--agent A]");
+        return 1;
+    }
+    const p = paths(values.config);
+    const config = tryLoadConfig(p);
+    const agent = values.agent ?? process.env.SPENDCTL_AGENT ?? config?.defaultAgent;
+    const headers = new Headers();
+    for (const header of values.header ?? []) {
+        const i = header.indexOf(":");
+        if (i > 0)
+            headers.set(header.slice(0, i).trim(), header.slice(i + 1).trim());
+    }
+    if (values["dry-run"])
+        headers.set("x-spendctl-dry-run", "1");
+    const tokens = readAgentTokens(p);
+    const doFetch = wrapFetch({ url: sidecarUrl(p), agent, token: agent ? tokens[agent] : undefined });
+    const started = Date.now();
+    let response;
+    try {
+        response = await doFetch(url, {
+            method: values.method ?? (values.data ? "POST" : "GET"),
+            headers,
+            body: values.data,
+        });
+    }
+    catch (error) {
+        const cause = error.cause;
+        if (cause?.code === "UND_ERR_HEADERS_TIMEOUT") {
+            // Node's fetch stops waiting for response headers after 300 s; a held approval outlived it.
+            err(`${c.red("✖")} gave up after 5 minutes waiting for the sidecar's answer (Node's fetch limit). If a human approval is pending, run \`spendctl pending\`; keep approvals.holdMax under 5m.`);
+            return 1;
+        }
+        err(`${c.red("✖")} cannot reach the sidecar at ${sidecarUrl(p)} — is \`spendctl start\` running? (${error.message})`);
+        return 1;
+    }
+    const ms = Date.now() - started;
+    const refusal = await readRefusal(response);
+    const text = await response.text();
+    const decision = response.headers.get("x-spendctl-decision");
+    const amount = response.headers.get("x-spendctl-amount");
+    if (!values.quiet) {
+        if (refusal) {
+            const icon = refusal.error === "spendctl_dry_run"
+                ? c.yellow("○")
+                : refusal.error === "spendctl_approval_required"
+                    ? c.yellow("⏸")
+                    : c.red("✖");
+            out(`${icon} ${response.status} ${c.bold(refusal.error)} ${c.gray(`${ms}ms`)}`);
+            out(`  ${refusal.message}`);
+            if (refusal.approval)
+                out(`  ${c.dim("approve with:")} spendctl approve ${refusal.approval}`);
+        }
+        else {
+            const paid = decision === "settled"
+                ? `${c.green("paid")} ${c.bold(amount ?? "")}`
+                : decision
+                    ? statusColor(decision)
+                    : c.dim("no payment");
+            out(`${response.ok ? c.green("✔") : c.red("✖")} ${response.status} ${paid} ${c.gray(`${ms}ms`)}`);
+        }
+    }
+    if (!refusal) {
+        try {
+            out(JSON.stringify(JSON.parse(text), null, 2));
+        }
+        catch {
+            out(text);
+        }
+    }
+    return response.ok ? 0 : refusal ? 2 : 1;
+}
+async function cmdPending(argv) {
+    const { values } = parse(argv, { ids: { type: "boolean" } });
+    const p = paths(values.config);
+    const { pending } = await admin(p).pending();
+    if (values.ids) {
+        for (const item of pending)
+            out(item.id);
+        return 0;
+    }
+    if (!pending.length) {
+        out(c.dim("Nothing is waiting for approval."));
+        return 0;
+    }
+    out(table(pending.map((item) => [
+        c.bold(item.id),
+        item.agent,
+        `${item.host}${item.path}`,
+        item.usdMicros !== undefined ? formatUsd(BigInt(item.usdMicros)) : "-",
+        `${Math.max(0, Math.round((item.expiresAt - Date.now()) / 1000))}s`,
+        item.reasons.map((r) => r.message).join(" "),
+    ]), ["ID", "AGENT", "ENDPOINT", "AMOUNT", "EXPIRES", "WHY"]));
+    return 0;
+}
+async function cmdDecide(argv, action) {
+    const { values, positionals } = parse(argv, {
+        latest: { type: "boolean" },
+        all: { type: "boolean" },
+        note: { type: "string" },
+    });
+    const p = paths(values.config);
+    const client = admin(p);
+    let ids = positionals;
+    if (values.latest || values.all) {
+        const { pending } = await client.pending();
+        ids = values.all ? pending.map((item) => item.id) : pending.slice(0, 1).map((item) => item.id);
+    }
+    if (!ids.length) {
+        err(values.latest || values.all
+            ? "Nothing is waiting for approval."
+            : `Usage: spendctl ${action} <approval-id> | --latest`);
+        return 1;
+    }
+    for (const id of ids) {
+        const result = action === "approve"
+            ? await client.approve(id, values.note)
+            : await client.deny(id, values.note);
+        out(`${action === "approve" ? c.green("✔ approved") : c.red("✖ denied")} ${result.approval.id}`);
+    }
+    return 0;
+}
+async function cmdBudget(argv) {
+    const { values } = parse(argv, { agent: { type: "string", short: "a" } });
+    const p = paths(values.config);
+    const summary = await admin(p).summary();
+    const agents = summary.agents.filter((a) => !values.agent || a.agent === values.agent);
+    for (const agent of agents) {
+        out(`${c.bold(agent.agent)} ${c.dim(agent.mode)}${agent.perRequest ? c.dim(` · max ${agent.perRequest}/request`) : ""}${agent.requireApprovalAbove ? c.dim(` · approval ≥ ${agent.requireApprovalAbove}`) : ""}`);
+        if (!agent.windows.length)
+            out(c.dim("  no time-window budgets"));
+        for (const w of agent.windows)
+            out(`  ${w.window.padEnd(8)} ${w.spent.padStart(10)} of ${w.limit.padEnd(10)} ${c.dim(`${w.remaining} left`)}`);
+    }
+    const plan = summary.plan;
+    if (plan)
+        out(`${c.dim("plan")} ${plan.exhausted ? c.yellow(planLine(plan)) : planLine(plan)}`);
+    return 0;
+}
+async function cmdLicense(argv) {
+    const { values, positionals } = parse(argv);
+    const p = paths(values.config);
+    const [action, key] = positionals;
+    if (action === "set") {
+        if (!key) {
+            err("usage: spendctl license set <key>");
+            return 1;
+        }
+        const plan = parseLicenseKey(key);
+        writeLicenseKey(p, key);
+        const expires = plan.expiresAt ? new Date(plan.expiresAt).toISOString().slice(0, 10) : "never";
+        out(`${c.green("✔")} licence key stored in ${relative(process.cwd(), p.license)} (${TIER_LABELS[plan.tier]}${plan.org ? `, ${plan.org}` : ""}, expires ${expires})`);
+        out(c.dim("Restart the sidecar to apply it. $SPENDCTL_LICENSE_KEY, when set, takes precedence over the file."));
+        return 0;
+    }
+    if (action === "remove") {
+        out(removeLicenseKey(p)
+            ? `${c.green("✔")} removed ${relative(process.cwd(), p.license)}; the sidecar runs with the Free limits after a restart`
+            : "No licence key file; nothing to remove.");
+        return 0;
+    }
+    if (action) {
+        err(`Unknown action "${action}" (use: spendctl license [set <key> | remove])`);
+        return 1;
+    }
+    const loaded = loadPlan(p);
+    if (loaded.warning)
+        err(`${c.yellow("!")} ${loaded.warning}`);
+    const where = loaded.source === "env"
+        ? "$SPENDCTL_LICENSE_KEY"
+        : loaded.source === "file"
+            ? relative(process.cwd(), p.license)
+            : "none (Free)";
+    out(`${c.dim("key    ")} ${where}`);
+    const usage = await usageFor(p, loaded.plan);
+    out(`${c.dim("plan   ")} ${planLine(usage)}`);
+    if (usage.exhausted)
+        out(c.yellow(`This month's cap is reached; new payments are refused until ${usage.resets}.`));
+    const warning = expiryWarning(loaded.plan);
+    if (warning)
+        out(c.yellow(warning));
+    return 0;
+}
+async function cmdLedger(argv) {
+    const { values } = parse(argv, { agent: { type: "string", short: "a" }, limit: { type: "string", short: "n" } });
+    const p = paths(values.config);
+    const { attempts } = await admin(p).ledger({
+        agent: values.agent,
+        limit: Number(values.limit ?? 20),
+    });
+    if (!attempts.length) {
+        out(c.dim("The ledger is empty."));
+        return 0;
+    }
+    out(table(attempts.map((a) => [
+        c.gray(a.created_at_utc.replace("T", " ").slice(5, 19)),
+        a.id,
+        a.agent,
+        `${a.method} ${a.host}${a.path}`,
+        a.usd_value ? `$${a.usd_value}` : "-",
+        statusColor(a.status),
+        a.tx_hash ? c.gray(short(a.tx_hash, 16)) : c.dim(a.reasons),
+    ]), ["TIME (UTC)", "ID", "AGENT", "ENDPOINT", "USD", "STATUS", "TX / REASON"]));
+    return 0;
+}
+async function cmdExport(argv) {
+    const { values } = parse(argv, {
+        format: { type: "string", short: "f" },
+        out: { type: "string", short: "o" },
+        agent: { type: "string", short: "a" },
+        since: { type: "string" },
+    });
+    const p = paths(values.config);
+    const format = values.format === "json" ? "json" : "csv";
+    const body = await admin(p).export(format, {
+        agent: values.agent,
+        since: values.since,
+    });
+    const text = typeof body === "string" ? body : `${JSON.stringify(body, null, 2)}\n`;
+    if (values.out) {
+        writeFileSync(String(values.out), text);
+        const rows = format === "csv" ? Math.max(0, text.trim().split("\n").length - 1) : JSON.parse(text).length;
+        out(`${c.green("✔")} wrote ${rows} row(s) to ${values.out}`);
+    }
+    else {
+        process.stdout.write(text);
+    }
+    return 0;
+}
+async function cmdTrace(argv) {
+    const { values, positionals } = parse(argv);
+    if (!positionals[0]) {
+        err("Usage: spendctl trace <attempt-id>");
+        return 1;
+    }
+    const p = paths(values.config);
+    out((await admin(p).trace(positionals[0])).text);
+    return 0;
+}
+async function cmdResolve(argv) {
+    const { values, positionals } = parse(argv, {
+        settled: { type: "boolean" },
+        failed: { type: "boolean" },
+        tx: { type: "string" },
+    });
+    const id = positionals[0];
+    if (!id || values.settled === values.failed) {
+        err("Usage: spendctl resolve <attempt-id> --settled|--failed [--tx HASH]");
+        return 1;
+    }
+    const p = paths(values.config);
+    await admin(p).resolve(id, values.settled ? "settled" : "failed", values.tx);
+    out(`${c.green("✔")} ${id} marked ${values.settled ? "settled" : "failed"}`);
+    return 0;
+}
+async function cmdDashboard(argv) {
+    const { values } = parse(argv, { open: { type: "boolean" } });
+    const p = paths(values.config);
+    const url = `${sidecarUrl(p)}/_spendctl/dashboard#token=${readAdminToken(p)}`;
+    out(url);
+    if (values.open)
+        spawn(process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open", [url], {
+            stdio: "ignore",
+            detached: true,
+        }).unref();
+    return 0;
+}
+async function cmdRun(argv) {
+    const split = argv.indexOf("--");
+    const own = split === -1 ? argv : argv.slice(0, split);
+    const command = split === -1 ? [] : argv.slice(split + 1);
+    const { values } = parse(own, { agent: { type: "string", short: "a" } });
+    if (!command.length || !values.agent) {
+        err("Usage: spendctl run --agent <name> -- <command...>");
+        return 1;
+    }
+    const p = paths(values.config);
+    const base = new URL(sidecarUrl(p));
+    const token = readAgentTokens(p)[String(values.agent)];
+    const proxy = `${base.protocol}//${encodeURIComponent(String(values.agent))}${token ? `:${token}` : ""}@${base.host}`;
+    const child = spawn(command[0], command.slice(1), {
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            HTTP_PROXY: proxy,
+            http_proxy: proxy,
+            NODE_USE_ENV_PROXY: "1",
+            SPENDCTL_URL: base.origin,
+            SPENDCTL_AGENT: String(values.agent),
+            ...(token ? { SPENDCTL_AGENT_TOKEN: token } : {}),
+        },
+    });
+    return new Promise((done) => child.on("exit", (code) => done(code ?? 1)));
+}
+async function cmdToken(argv) {
+    const { values, positionals } = parse(argv);
+    const agent = positionals[0];
+    if (!agent) {
+        err("Usage: spendctl token <agent>");
+        return 1;
+    }
+    const p = paths(values.config);
+    const tokens = readAgentTokens(p);
+    tokens[agent] ??= newToken(16);
+    writeAgentTokens(p, tokens);
+    out(tokens[agent]);
+    return 0;
+}
+async function cmdWallet(argv) {
+    const { values, positionals } = parse(argv, { amount: { type: "string" } });
+    const p = paths(values.config);
+    loadDotenv(p.root);
+    const config = loadConfig(p.config);
+    const action = positionals[0] ?? "address";
+    const signer = await createSigner(config.signer);
+    if (action === "address") {
+        out(`${signer.address}  ${c.dim(signer.description)}`);
+        return 0;
+    }
+    if (action === "fund") {
+        if (config.signer.type !== "cdp") {
+            err("`wallet fund` uses the CDP faucet and needs signer.type: cdp.");
+            return 1;
+        }
+        const result = await requestTestnetUsdc(signer.address);
+        out(`${c.green("✔")} requested 1 testnet USDC for ${signer.address}`);
+        out(`  https://sepolia.basescan.org/tx/${result.transactionHash}`);
+        return 0;
+    }
+    err("Usage: spendctl wallet [address|fund]");
+    return 1;
+}
+async function cmdMcp() {
+    const { serveStdio } = await import("@spendctl/mcp-server");
+    await serveStdio();
+    await new Promise(() => undefined);
+    return 0;
+}
+const COMMANDS = {
+    init: cmdInit,
+    start: cmdStart,
+    mock: cmdMock,
+    fetch: cmdFetch,
+    pending: cmdPending,
+    approve: (argv) => cmdDecide(argv, "approve"),
+    deny: (argv) => cmdDecide(argv, "deny"),
+    budget: cmdBudget,
+    ledger: cmdLedger,
+    export: cmdExport,
+    trace: cmdTrace,
+    resolve: cmdResolve,
+    dashboard: cmdDashboard,
+    run: cmdRun,
+    token: cmdToken,
+    wallet: cmdWallet,
+    license: cmdLicense,
+    mcp: cmdMcp,
+};
+export async function main(argv) {
+    const [command, ...rest] = argv;
+    if (!command || command === "-h" || command === "--help" || command === "help") {
+        out(HELP);
+        return 0;
+    }
+    if (command === "-v" || command === "--version") {
+        out(VERSION);
+        return 0;
+    }
+    const handler = COMMANDS[command];
+    if (!handler) {
+        err(`Unknown command "${command}". Run \`spendctl --help\`.`);
+        return 1;
+    }
+    if (rest.includes("--help") || rest.includes("-h")) {
+        out(HELP);
+        return 0;
+    }
+    try {
+        return await handler(rest);
+    }
+    catch (error) {
+        if (error instanceof ConfigError || error instanceof LicenseError || error instanceof PlanError)
+            err(c.red(error.message));
+        else
+            err(`${c.red("✖")} ${error.message}`);
+        return 1;
+    }
+}
+//# sourceMappingURL=index.js.map