agentspend 0.1.3 → 0.1.5

package/README.md

@@ -0,0 +1,43 @@
+# AgentSpend
+
+CLI for managing AI agent payment methods — cards (Stripe) and crypto wallets (USDC on Base).
+
+## Install
+
+```bash
+npm install -g agentspend
+```
+
+## Card setup (Stripe)
+
+```bash
+# Start card setup — opens Stripe in your browser
+agentspend card setup
+
+# Check setup status
+agentspend card status
+```
+
+`card setup` creates a card via the AgentSpend API, opens the Stripe setup URL in your browser, and polls until the card is ready. The `card_id` is saved to `~/.agentspend/card.json`.
+
+Agents use the `card_id` to pay services by sending `x-card-id: card_xxx` in request headers.
+
+## Wallet (crypto)
+
+```bash
+# Generate a new wallet for x402 payments
+agentspend wallet create
+
+# Show address, network, and USDC balance
+agentspend wallet status
+```
+
+`wallet create` generates a local private key and saves it to `~/.agentspend/wallet.json`. Fund the address with USDC on Base to pay x402-enabled services.
+
+## Configuration
+
+| Variable | Description |
+|----------|-------------|
+| `AGENTSPEND_API_URL` | Platform API base URL (default: `https://api.agentspend.co`) |
+
+Config files are stored in `~/.agentspend/`.

package/dist/commands/pay.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerPayCommand(program: Command): void;

package/dist/commands/pay.js

@@ -0,0 +1,184 @@
+"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");
+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) {
+            return data;
+        }
+    }
+    catch {
+        // file doesn't exist or is invalid
+    }
+    return 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 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;
+}
+async function payWithCard(url, cardId, body, extraHeaders) {
+    const headers = {
+        ...extraHeaders,
+        "x-card-id": cardId,
+    };
+    if (body) {
+        headers["content-type"] = "application/json";
+    }
+    const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: body ?? undefined,
+    });
+    const data = await res.text();
+    if (!res.ok) {
+        console.error(`Request failed (${res.status}): ${data}`);
+        process.exit(1);
+    }
+    console.log("Payment successful (card)");
+    try {
+        console.log(JSON.stringify(JSON.parse(data), null, 2));
+    }
+    catch {
+        console.log(data);
+    }
+}
+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);
+    }
+    // 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);
+    }
+    console.log("Payment successful (crypto)");
+    try {
+        console.log(JSON.stringify(JSON.parse(data), null, 2));
+    }
+    catch {
+        console.log(data);
+    }
+}
+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);
+                }
+                await payWithCard(url, card.card_id, 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);
+                return;
+            }
+            // Auto-detect: try card first, then crypto
+            const card = await readCardConfig();
+            if (card) {
+                await payWithCard(url, card.card_id, opts.body, extraHeaders);
+                return;
+            }
+            const wallet = await readWalletConfig();
+            if (wallet) {
+                await payWithCrypto(url, wallet, opts.body, extraHeaders);
+                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);
+        }
+    });
+}

package/dist/index.js

@@ -4,6 +4,7 @@ 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")
@@ -11,4 +12,5 @@ program
     .version("0.1.0");
 (0, card_js_1.registerCardCommands)(program);
 (0, wallet_js_1.registerWalletCommands)(program);
+(0, pay_js_1.registerPayCommand)(program);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentspend",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "CLI for AgentSpend — manage cards and crypto wallets for AI agent payments",
   "repository": {
     "type": "git",
@@ -10,6 +10,8 @@
     "agentspend": "dist/index.js"
   },
   "dependencies": {
+    "@x402/core": "^2.3.1",
+    "@x402/evm": "^2.3.1",
     "commander": "^13.0.0",
     "viem": "^2.0.0"
   },

package/src/commands/pay.ts

@@ -0,0 +1,224 @@
+import { Command } from "commander";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const CONFIG_DIR = join(homedir(), ".agentspend");
+const CARD_FILE = join(CONFIG_DIR, "card.json");
+const WALLET_FILE = join(CONFIG_DIR, "wallet.json");
+
+interface CardConfig {
+  card_id: string;
+}
+
+interface WalletConfig {
+  address: string;
+  network: string;
+  private_key: string;
+}
+
+async function readCardConfig(): Promise<CardConfig | null> {
+  try {
+    const data = JSON.parse(await readFile(CARD_FILE, "utf-8"));
+    if (typeof data.card_id === "string" && data.card_id) {
+      return data as CardConfig;
+    }
+  } catch {
+    // file doesn't exist or is invalid
+  }
+  return null;
+}
+
+async function readWalletConfig(): Promise<WalletConfig | null> {
+  try {
+    const data = JSON.parse(await readFile(WALLET_FILE, "utf-8"));
+    if (typeof data.address === "string" && data.address) {
+      return data as WalletConfig;
+    }
+  } catch {
+    // file doesn't exist or is invalid
+  }
+  return null;
+}
+
+function parseHeaders(headerArgs: string[]): Record<string, string> {
+  const headers: Record<string, string> = {};
+  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;
+}
+
+async function payWithCard(
+  url: string,
+  cardId: string,
+  body: string | undefined,
+  extraHeaders: Record<string, string>
+): Promise<void> {
+  const headers: Record<string, string> = {
+    ...extraHeaders,
+    "x-card-id": cardId,
+  };
+  if (body) {
+    headers["content-type"] = "application/json";
+  }
+
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: body ?? undefined,
+  });
+
+  const data = await res.text();
+  if (!res.ok) {
+    console.error(`Request failed (${res.status}): ${data}`);
+    process.exit(1);
+  }
+
+  console.log("Payment successful (card)");
+  try {
+    console.log(JSON.stringify(JSON.parse(data), null, 2));
+  } catch {
+    console.log(data);
+  }
+}
+
+async function payWithCrypto(
+  url: string,
+  walletConfig: WalletConfig,
+  body: string | undefined,
+  extraHeaders: Record<string, string>
+): Promise<void> {
+  const headers: Record<string, string> = { ...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);
+  }
+
+  // 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 as `0x${string}`);
+
+  const coreClient = new x402Client();
+  registerExactEvmScheme(coreClient, { signer: account });
+  const httpClient = new x402HTTPClient(coreClient);
+
+  // Decode payment requirements from 402 response
+  const paymentRequired = httpClient.getPaymentRequiredResponse(
+    (name: string) => 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);
+  }
+
+  console.log("Payment successful (crypto)");
+  try {
+    console.log(JSON.stringify(JSON.parse(data), null, 2));
+  } catch {
+    console.log(data);
+  }
+}
+
+export function registerPayCommand(program: Command): void {
+  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: string, prev: string[]) => {
+      prev.push(val);
+      return prev;
+    }, [] as string[])
+    .action(async (url: string, opts: { method?: string; body?: string; header: string[] }) => {
+      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);
+          }
+          await payWithCard(url, card.card_id, 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);
+          return;
+        }
+
+        // Auto-detect: try card first, then crypto
+        const card = await readCardConfig();
+        if (card) {
+          await payWithCard(url, card.card_id, opts.body, extraHeaders);
+          return;
+        }
+
+        const wallet = await readWalletConfig();
+        if (wallet) {
+          await payWithCrypto(url, wallet, opts.body, extraHeaders);
+          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: unknown) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
+    });
+}

package/src/index.ts

@@ -3,6 +3,7 @@
 import { Command } from "commander";
 import { registerCardCommands } from "./commands/card.js";
 import { registerWalletCommands } from "./commands/wallet.js";
+import { registerPayCommand } from "./commands/pay.js";
 
 const program = new Command();
 
@@ -13,5 +14,6 @@ program
 
 registerCardCommands(program);
 registerWalletCommands(program);
+registerPayCommand(program);
 
 program.parse();