@useagentpay/mcp-server 0.1.2 → 0.1.4

package/dist/cli.js

@@ -0,0 +1,1301 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/templates/agent-md.ts
+function generateAgentMd() {
+  return `# AgentPay
+
+You have access to AgentPay for making purchases on behalf of the user.
+
+## Purchase Flow
+
+1. **Check balance** \u2014 call \`agentpay_check_balance\` before proposing
+2. **Propose** \u2014 call \`agentpay_propose_purchase\` with merchant, amount, description, and URL
+3. **Open the dashboard** \u2014 run \`npx @useagentpay/mcp-server dashboard\` so the human can approve
+4. **Wait** \u2014 call \`agentpay_wait_for_approval\` to poll until approved or rejected
+5. **Execute** \u2014 call \`agentpay_execute_purchase\` once approved
+6. **Receipt** \u2014 call \`agentpay_get_receipt\` and share the result with the human
+
+## MCP Tools
+
+- \`agentpay_status\` \u2014 check setup state, balance, and budget
+- \`agentpay_check_balance\` \u2014 current balance and limits
+- \`agentpay_propose_purchase\` \u2014 propose a new purchase
+- \`agentpay_wait_for_approval\` \u2014 poll until human approves or rejects
+- \`agentpay_execute_purchase\` \u2014 execute an approved purchase
+- \`agentpay_get_receipt\` \u2014 get receipt after purchase
+- \`agentpay_list_pending\` \u2014 list pending proposals
+- \`agentpay_get_transaction\` \u2014 get transaction details
+
+## Dashboard \u2014 Human-Only Configuration
+
+Budget, spending limits, funds, and credentials can ONLY be changed through the browser dashboard. If the user wants to change any of these, open the dashboard for them:
+
+\`\`\`
+npx @useagentpay/mcp-server dashboard
+\`\`\`
+
+If AgentPay isn't set up yet, run setup for them:
+
+\`\`\`
+npx @useagentpay/mcp-server setup
+\`\`\`
+
+After setup completes, these files are created in \`agentpay/\`:
+- \`credentials.enc\` \u2014 encrypted card and billing details
+- \`keys/\` \u2014 Ed25519 keypair for signing approvals
+- \`wallet.json\` \u2014 budget, per-transaction limit, and balance
+- \`transactions.json\` \u2014 purchase log
+- \`audit.log\` \u2014 action log
+
+## Rules
+
+- Always check balance before proposing
+- Never propose a purchase without a clear reason
+- Never skip the approval step \u2014 open the dashboard and wait
+- If rejected, respect the decision and suggest alternatives
+- You CANNOT modify budgets, spending limits, or credentials \u2014 open the dashboard for the human to do it
+`;
+}
+var init_agent_md = __esm({
+  "src/templates/agent-md.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initCommand: () => initCommand
+});
+import { mkdirSync, existsSync } from "fs";
+import { writeFileSync } from "fs";
+import { join } from "path";
+function initCommand() {
+  const dir = join(process.cwd(), "agentpay");
+  if (existsSync(dir)) {
+    console.log(`AgentPay already initialized at ${dir}`);
+    return;
+  }
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "AGENT.md"), generateAgentMd(), "utf-8");
+  console.log("AgentPay initialized. Run `agentpay setup` to add your payment credentials.");
+}
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_agent_md();
+  }
+});
+
+// src/commands/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  setupCommand: () => setupCommand
+});
+import { requestBrowserSetup } from "@useagentpay/sdk";
+async function setupCommand() {
+  console.log("AgentPay Setup");
+  console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+  console.log("Opening setup form in browser...\n");
+  const result = await requestBrowserSetup();
+  if (result.completed) {
+    console.log("\nSetup complete! Next steps:");
+    console.log("  agentpay status     Check your wallet");
+    console.log("  agentpay budget     View/adjust budget");
+  }
+}
+var init_setup = __esm({
+  "src/commands/setup.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/budget.ts
+var budget_exports = {};
+__export(budget_exports, {
+  budgetCommand: () => budgetCommand
+});
+import { BudgetManager, formatCurrency } from "@useagentpay/sdk";
+function budgetCommand() {
+  const bm = new BudgetManager();
+  const balance = bm.getBalance();
+  console.log(`Budget:       ${formatCurrency(balance.budget)}`);
+  console.log(`Balance:      ${formatCurrency(balance.balance)}`);
+  console.log(`Spent:        ${formatCurrency(balance.spent)}`);
+  console.log(`Per-tx limit: ${balance.limitPerTx > 0 ? formatCurrency(balance.limitPerTx) : "None"}`);
+}
+var init_budget = __esm({
+  "src/commands/budget.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/pending.ts
+var pending_exports = {};
+__export(pending_exports, {
+  pendingCommand: () => pendingCommand
+});
+import { TransactionManager, formatCurrency as formatCurrency2 } from "@useagentpay/sdk";
+function pendingCommand() {
+  const tm = new TransactionManager();
+  const pending = tm.getPending();
+  if (pending.length === 0) {
+    console.log("No pending purchases.");
+    return;
+  }
+  console.log("Pending Purchases:");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("TX_ID         MERCHANT        AMOUNT    DESCRIPTION");
+  for (const tx of pending) {
+    const id = tx.id.padEnd(14);
+    const merchant = tx.merchant.padEnd(16);
+    const amount = formatCurrency2(tx.amount).padStart(9);
+    console.log(`${id}${merchant}${amount}    ${tx.description}`);
+  }
+  console.log(`
+${pending.length} pending purchase${pending.length === 1 ? "" : "s"}. Use 'agentpay approve <txId>' or 'agentpay reject <txId>'.`);
+}
+var init_pending = __esm({
+  "src/commands/pending.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/propose.ts
+var propose_exports = {};
+__export(propose_exports, {
+  proposeCommand: () => proposeCommand
+});
+import {
+  BudgetManager as BudgetManager2,
+  TransactionManager as TransactionManager2,
+  AuditLogger,
+  formatCurrency as formatCurrency3
+} from "@useagentpay/sdk";
+function proposeCommand(options) {
+  const amount = parseFloat(options.amount);
+  if (isNaN(amount) || amount <= 0) {
+    console.error("Invalid amount. Must be a positive number.");
+    process.exit(1);
+  }
+  const bm = new BudgetManager2();
+  const tm = new TransactionManager2();
+  const audit = new AuditLogger();
+  try {
+    bm.checkProposal(amount);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : "Budget check failed.");
+    process.exit(1);
+  }
+  const tx = tm.propose({
+    merchant: options.merchant,
+    amount,
+    description: options.description,
+    url: options.url
+  });
+  audit.log("PROPOSE", { txId: tx.id, merchant: tx.merchant, amount: tx.amount, source: "propose-command" });
+  console.log("Transaction proposed");
+  console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+  console.log(`  ID:          ${tx.id}`);
+  console.log(`  Merchant:    ${tx.merchant}`);
+  console.log(`  Amount:      ${formatCurrency3(tx.amount)}`);
+  console.log(`  Description: ${tx.description}`);
+  console.log(`  URL:         ${options.url}`);
+  console.log(`  Status:      ${tx.status}`);
+  console.log();
+  console.log(`Next step: agentpay approve ${tx.id}`);
+}
+var init_propose = __esm({
+  "src/commands/propose.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/approve.ts
+var approve_exports = {};
+__export(approve_exports, {
+  approveCommand: () => approveCommand
+});
+import {
+  TransactionManager as TransactionManager3,
+  AuditLogger as AuditLogger2,
+  formatCurrency as formatCurrency4,
+  requestBrowserApproval
+} from "@useagentpay/sdk";
+async function approveCommand(txId) {
+  const tm = new TransactionManager3();
+  const audit = new AuditLogger2();
+  const tx = tm.get(txId);
+  if (!tx) {
+    console.error(`Transaction ${txId} not found.`);
+    process.exit(1);
+  }
+  if (tx.status !== "pending") {
+    console.error(`Cannot approve transaction in '${tx.status}' state.`);
+    process.exit(1);
+  }
+  console.log(`Approve purchase:`);
+  console.log(`  Merchant:    ${tx.merchant}`);
+  console.log(`  Amount:      ${formatCurrency4(tx.amount)}`);
+  console.log(`  Description: ${tx.description}`);
+  console.log();
+  const result = await requestBrowserApproval(tx, tm, audit);
+  if (result.action === "rejected") {
+    console.log(`Purchase denied${result.reason ? ": " + result.reason : "."}`);
+    process.exit(0);
+  }
+  console.log(`
+Approved! Transaction ${txId} is now ready for execution.`);
+}
+var init_approve = __esm({
+  "src/commands/approve.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/reject.ts
+var reject_exports = {};
+__export(reject_exports, {
+  rejectCommand: () => rejectCommand
+});
+import { TransactionManager as TransactionManager4, AuditLogger as AuditLogger3 } from "@useagentpay/sdk";
+function rejectCommand(txId, options) {
+  const tm = new TransactionManager4();
+  const audit = new AuditLogger3();
+  const tx = tm.get(txId);
+  if (!tx) {
+    console.error(`Transaction ${txId} not found.`);
+    process.exit(1);
+  }
+  if (tx.status !== "pending") {
+    console.error(`Cannot reject transaction in '${tx.status}' state.`);
+    process.exit(1);
+  }
+  tm.reject(txId, options.reason);
+  audit.log("REJECT", { txId, reason: options.reason });
+  console.log(`Rejected transaction ${txId}.${options.reason ? ` Reason: ${options.reason}` : ""}`);
+}
+var init_reject = __esm({
+  "src/commands/reject.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/status.ts
+var status_exports = {};
+__export(status_exports, {
+  statusCommand: () => statusCommand
+});
+import { AgentPay, formatStatus } from "@useagentpay/sdk";
+function statusCommand() {
+  const ap = new AgentPay();
+  const s = ap.status();
+  if (!s.isSetup) {
+    console.log("AgentPay is not set up. Run `agentpay setup` first.");
+    return;
+  }
+  console.log(formatStatus({
+    balance: s.balance,
+    budget: s.budget,
+    limitPerTx: s.limitPerTx,
+    pending: s.pending,
+    recent: s.recent
+  }));
+}
+var init_status = __esm({
+  "src/commands/status.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/history.ts
+var history_exports = {};
+__export(history_exports, {
+  historyCommand: () => historyCommand
+});
+import { TransactionManager as TransactionManager5, formatCurrency as formatCurrency5, formatTimestamp } from "@useagentpay/sdk";
+function historyCommand() {
+  const tm = new TransactionManager5();
+  const history = tm.getHistory();
+  if (history.length === 0) {
+    console.log("No transaction history.");
+    return;
+  }
+  console.log("Transaction History:");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("STATUS       TX_ID         MERCHANT        AMOUNT    DATE              DESCRIPTION");
+  for (const tx of history) {
+    const status = `[${tx.status}]`.padEnd(13);
+    const id = tx.id.padEnd(14);
+    const merchant = tx.merchant.padEnd(16);
+    const amount = formatCurrency5(tx.amount).padStart(9);
+    const date = formatTimestamp(tx.createdAt).padEnd(18);
+    console.log(`${status}${id}${merchant}${amount}    ${date}${tx.description}`);
+  }
+}
+var init_history = __esm({
+  "src/commands/history.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/reset.ts
+var reset_exports = {};
+__export(reset_exports, {
+  resetCommand: () => resetCommand
+});
+import { rmSync, existsSync as existsSync2 } from "fs";
+import { getHomePath, promptInput } from "@useagentpay/sdk";
+async function resetCommand() {
+  const home = getHomePath();
+  if (!existsSync2(home)) {
+    console.log("Nothing to reset. AgentPay data directory does not exist.");
+    return;
+  }
+  console.log(`This will permanently delete all AgentPay data at: ${home}`);
+  console.log("This includes encrypted credentials, keys, wallet, transactions, and audit logs.");
+  const answer = await promptInput("\nType YES to confirm: ");
+  if (answer !== "YES") {
+    console.log("Cancelled.");
+    return;
+  }
+  rmSync(home, { recursive: true, force: true });
+  console.log("All AgentPay data has been deleted.");
+}
+var init_reset = __esm({
+  "src/commands/reset.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/dashboard.ts
+var dashboard_exports = {};
+__export(dashboard_exports, {
+  dashboardCommand: () => dashboardCommand
+});
+import { startDashboardServer, openBrowser } from "@useagentpay/sdk";
+async function dashboardCommand(options) {
+  const port = parseInt(options.port, 10) || 3141;
+  const url = `http://127.0.0.1:${port}`;
+  try {
+    const server = await startDashboardServer(port);
+    console.log(`AgentPay Dashboard running at ${url}`);
+    console.log("Press Ctrl+C to stop.\n");
+    openBrowser(url);
+    const shutdown = () => {
+      console.log("\nShutting down dashboard...");
+      server.close(() => process.exit(0));
+      setTimeout(() => process.exit(0), 3e3);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to start server";
+    console.error(message);
+    process.exit(1);
+  }
+}
+var init_dashboard = __esm({
+  "src/commands/dashboard.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/errors.ts
+import {
+  NotSetupError,
+  DecryptError,
+  InsufficientBalanceError,
+  ExceedsTxLimitError,
+  NotApprovedError,
+  InvalidMandateError,
+  AlreadyExecutedError,
+  CheckoutFailedError,
+  TimeoutError
+} from "@useagentpay/sdk";
+function mapError(err) {
+  if (err instanceof Error) {
+    for (const mapping of ERROR_MAP) {
+      if (err instanceof mapping.type) {
+        return {
+          success: false,
+          error: mapping.error,
+          message: err.message,
+          nextAction: mapping.nextAction
+        };
+      }
+    }
+  }
+  return {
+    success: false,
+    error: "UNKNOWN_ERROR",
+    message: err instanceof Error ? err.message : String(err)
+  };
+}
+var ERROR_MAP;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    init_esm_shims();
+    ERROR_MAP = [
+      { type: NotSetupError, error: "NOT_SETUP", nextAction: "STOP - Human must run: agentpay setup" },
+      { type: InsufficientBalanceError, error: "INSUFFICIENT_BALANCE", nextAction: "STOP - Human must add budget" },
+      { type: ExceedsTxLimitError, error: "EXCEEDS_TX_LIMIT", nextAction: "STOP - Human must increase limit" },
+      { type: NotApprovedError, error: "NOT_APPROVED", nextAction: "WAIT - Needs approval first" },
+      { type: InvalidMandateError, error: "INVALID_MANDATE", nextAction: "STOP - Security error" },
+      { type: AlreadyExecutedError, error: "ALREADY_EXECUTED", nextAction: "STOP - Already processed" },
+      { type: CheckoutFailedError, error: "CHECKOUT_FAILED", nextAction: "ERROR - Human should review" },
+      { type: TimeoutError, error: "TIMEOUT", nextAction: "RETRY - Try again later" },
+      { type: DecryptError, error: "DECRYPT_FAILED", nextAction: "STOP - Wrong passphrase" }
+    ];
+  }
+});
+
+// src/tools/status.ts
+function registerStatusTools(server, ap) {
+  server.tool(
+    "agentpay_status",
+    "Get AgentPay status: setup state, balance, budget, and pending transactions. Call this first.",
+    {},
+    async () => {
+      try {
+        const status = ap.status();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                ...status,
+                pendingCount: status.pending.length,
+                nextAction: !status.isSetup ? "STOP - Human must run: agentpay setup" : status.pending.length > 0 ? "Review pending transactions with agentpay_list_pending" : "Ready for purchases. Use agentpay_check_balance before proposing."
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify(mapError(err)) }] };
+      }
+    }
+  );
+  server.tool(
+    "agentpay_check_balance",
+    "Check current balance, budget, and per-transaction limit. Call BEFORE proposing a purchase.",
+    {},
+    async () => {
+      try {
+        const wallet = ap.wallet.getBalance();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                ...wallet,
+                nextAction: wallet.balance <= 0 ? "STOP - No balance remaining. Human must add budget." : `Ready. Max single purchase: $${Math.min(wallet.balance, wallet.limitPerTx).toFixed(2)}`
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify(mapError(err)) }] };
+      }
+    }
+  );
+  server.tool(
+    "agentpay_list_pending",
+    "List all pending transactions awaiting human approval.",
+    {},
+    async () => {
+      try {
+        const status = ap.status();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                pending: status.pending,
+                count: status.pending.length,
+                nextAction: status.pending.length > 0 ? "Human must approve/reject via CLI. Use agentpay_wait_for_approval to poll." : "No pending transactions."
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify(mapError(err)) }] };
+      }
+    }
+  );
+}
+var init_status2 = __esm({
+  "src/tools/status.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_errors();
+  }
+});
+
+// src/tools/propose.ts
+import { z } from "zod";
+function registerProposeTool(server, ap) {
+  server.tool(
+    "agentpay_propose_purchase",
+    "Propose a new purchase. Creates a pending transaction that requires human approval before execution.",
+    {
+      merchant: z.string().describe('Merchant name (e.g. "Amazon", "Target")'),
+      amount: z.number().positive().describe("Purchase amount in USD"),
+      description: z.string().describe("What is being purchased"),
+      url: z.string().url().describe("Product or checkout URL")
+    },
+    async ({ merchant, amount, description, url }) => {
+      try {
+        const tx = ap.transactions.propose({ merchant, amount, description, url });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                txId: tx.id,
+                status: tx.status,
+                merchant: tx.merchant,
+                amount: tx.amount,
+                nextAction: `Purchase proposed. Open the dashboard for the human to approve: npx @useagentpay/mcp-server dashboard \u2014 then call agentpay_wait_for_approval with txId "${tx.id}".`
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify(mapError(err)) }] };
+      }
+    }
+  );
+}
+var init_propose2 = __esm({
+  "src/tools/propose.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_errors();
+  }
+});
+
+// src/tools/transactions.ts
+import { z as z2 } from "zod";
+function nextActionForStatus(status) {
+  switch (status) {
+    case "pending":
+      return "WAIT - Human must approve via CLI. Use agentpay_wait_for_approval to poll.";
+    case "approved":
+      return "READY - Use agentpay_execute_purchase to complete the purchase.";
+    case "rejected":
+      return "STOP - Transaction was rejected by human.";
+    case "executing":
+      return "WAIT - Purchase is being executed.";
+    case "completed":
+      return "DONE - Use agentpay_get_receipt for confirmation details.";
+    case "failed":
+      return "ERROR - Purchase failed. Human should review.";
+    default:
+      return "Unknown status.";
+  }
+}
+function registerTransactionTools(server, ap) {
+  server.tool(
+    "agentpay_get_transaction",
+    "Get the current status and details of a transaction.",
+    {
+      txId: z2.string().describe('Transaction ID (e.g. "tx_abc123")')
+    },
+    async ({ txId }) => {
+      try {
+        const tx = ap.transactions.get(txId);
+        if (!tx) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  error: "NOT_FOUND",
+                  message: `Transaction ${txId} not found.`
+                })
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                id: tx.id,
+                status: tx.status,
+                merchant: tx.merchant,
+                amount: tx.amount,
+                description: tx.description,
+                url: tx.url,
+                createdAt: tx.createdAt,
+                nextAction: nextActionForStatus(tx.status)
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify(mapError(err)) }] };
+      }
+    }
+  );
+  server.tool(
+    "agentpay_wait_for_approval",
+    "Long-poll for human approval of a pending transaction. Blocks until approved, rejected, or timeout.",
+    {
+      txId: z2.string().describe("Transaction ID to wait for"),
+      pollInterval: z2.number().positive().optional().describe("Poll interval in ms (default 2000)"),
+      timeout: z2.number().positive().optional().describe("Timeout in ms (default 300000 = 5 min)")
+    },
+    async ({ txId, pollInterval, timeout }) => {
+      try {
+        const result = await ap.transactions.waitForApproval(txId, {
+          pollInterval: pollInterval ?? 2e3,
+          timeout: timeout ?? 3e5
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                txId,
+                status: result.status,
+                reason: result.reason,
+                nextAction: nextActionForStatus(result.status)
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify(mapError(err)) }] };
+      }
+    }
+  );
+}
+var init_transactions = __esm({
+  "src/tools/transactions.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_errors();
+  }
+});
+
+// src/config.ts
+function loadConfig(overrides) {
+  const passphrase = process.env.AGENTPAY_PASSPHRASE;
+  const passphraseServer = process.env.AGENTPAY_PASSPHRASE_SERVER;
+  let passphraseMode = "none";
+  if (passphrase) passphraseMode = "env";
+  else if (passphraseServer) passphraseMode = "server";
+  const executor = {
+    modelApiKey: process.env.ANTHROPIC_API_KEY
+  };
+  return {
+    home: process.env.AGENTPAY_HOME || void 0,
+    passphrase,
+    passphraseServer,
+    passphraseMode,
+    executor,
+    http: overrides?.http ?? process.env.MCP_TRANSPORT === "http"
+  };
+}
+async function getPassphrase(config) {
+  if (config.passphraseMode === "env" && config.passphrase) {
+    return config.passphrase;
+  }
+  if (config.passphraseMode === "server" && config.passphraseServer) {
+    const res = await fetch(config.passphraseServer);
+    if (!res.ok) throw new Error(`Passphrase server returned ${res.status}`);
+    const body = await res.text();
+    return body.trim();
+  }
+  throw new Error(
+    "No passphrase configured. Set AGENTPAY_PASSPHRASE or AGENTPAY_PASSPHRASE_SERVER to enable purchase execution."
+  );
+}
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/tools/execute.ts
+import { z as z3 } from "zod";
+import { AgentPay as AgentPay2 } from "@useagentpay/sdk";
+function registerExecuteTool(server, ap, config) {
+  server.tool(
+    "agentpay_execute_purchase",
+    "Execute an approved purchase. Requires passphrase config. Decrypts credentials and completes checkout via browser.",
+    {
+      txId: z3.string().describe("Transaction ID of an approved purchase")
+    },
+    async ({ txId }) => {
+      try {
+        const passphrase = await getPassphrase(config);
+        const execAp = new AgentPay2({
+          home: ap.home,
+          passphrase,
+          executor: config.executor
+        });
+        const receipt = await execAp.transactions.execute(txId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                receipt,
+                nextAction: "DONE - Purchase completed. Use agentpay_get_receipt for details."
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify(mapError(err)) }] };
+      }
+    }
+  );
+}
+var init_execute = __esm({
+  "src/tools/execute.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_errors();
+  }
+});
+
+// src/tools/receipt.ts
+import { z as z4 } from "zod";
+function registerReceiptTool(server, ap) {
+  server.tool(
+    "agentpay_get_receipt",
+    "Get the receipt for a completed purchase.",
+    {
+      txId: z4.string().describe("Transaction ID of a completed purchase")
+    },
+    async ({ txId }) => {
+      try {
+        const receipt = ap.transactions.getReceipt(txId);
+        if (!receipt) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  error: "NO_RECEIPT",
+                  message: `No receipt found for transaction ${txId}. Transaction may not be completed yet.`,
+                  nextAction: "Check transaction status with agentpay_get_transaction"
+                })
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                receipt,
+                nextAction: "DONE - Purchase confirmed."
+              })
+            }
+          ]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify(mapError(err)) }] };
+      }
+    }
+  );
+}
+var init_receipt = __esm({
+  "src/tools/receipt.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_errors();
+  }
+});
+
+// src/tools/index.ts
+function registerTools(server, ap, config) {
+  registerStatusTools(server, ap);
+  registerProposeTool(server, ap);
+  registerTransactionTools(server, ap);
+  registerExecuteTool(server, ap, config);
+  registerReceiptTool(server, ap);
+}
+var init_tools = __esm({
+  "src/tools/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_status2();
+    init_propose2();
+    init_transactions();
+    init_execute();
+    init_receipt();
+  }
+});
+
+// src/resources/wallet.ts
+function registerWalletResource(server, ap) {
+  server.resource("wallet", "agentpay://wallet", async () => {
+    try {
+      const wallet = ap.wallet.getBalance();
+      return {
+        contents: [
+          {
+            uri: "agentpay://wallet",
+            mimeType: "application/json",
+            text: JSON.stringify(wallet, null, 2)
+          }
+        ]
+      };
+    } catch {
+      return {
+        contents: [
+          {
+            uri: "agentpay://wallet",
+            mimeType: "application/json",
+            text: JSON.stringify({ budget: 0, balance: 0, limitPerTx: 0, spent: 0 })
+          }
+        ]
+      };
+    }
+  });
+}
+var init_wallet = __esm({
+  "src/resources/wallet.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/resources/transaction.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerTransactionResource(server, ap) {
+  server.resource(
+    "transaction",
+    new ResourceTemplate("agentpay://transactions/{txId}", { list: void 0 }),
+    async (uri, { txId }) => {
+      const tx = ap.transactions.get(txId);
+      if (!tx) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({ error: "Transaction not found" })
+            }
+          ]
+        };
+      }
+      const { mandate: _, ...safeTx } = tx;
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(safeTx, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+var init_transaction = __esm({
+  "src/resources/transaction.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/resources/audit.ts
+function registerAuditResource(server, ap) {
+  server.resource("audit-log", "agentpay://audit-log", async () => {
+    const lines = ap.audit.getLog();
+    const last50 = lines.slice(-50);
+    const entries = last50.map((line) => {
+      const parts = line.split("	");
+      return {
+        timestamp: parts[0] ?? "",
+        action: parts[1] ?? "",
+        details: parts[2] ? JSON.parse(parts[2]) : {}
+      };
+    });
+    return {
+      contents: [
+        {
+          uri: "agentpay://audit-log",
+          mimeType: "application/json",
+          text: JSON.stringify(entries, null, 2)
+        }
+      ]
+    };
+  });
+}
+var init_audit = __esm({
+  "src/resources/audit.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/resources/index.ts
+function registerResources(server, ap) {
+  registerWalletResource(server, ap);
+  registerTransactionResource(server, ap);
+  registerAuditResource(server, ap);
+}
+var init_resources = __esm({
+  "src/resources/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_wallet();
+    init_transaction();
+    init_audit();
+  }
+});
+
+// src/prompts/buy.ts
+import { z as z5 } from "zod";
+function registerBuyPrompt(server) {
+  server.prompt(
+    "buy",
+    "Step-by-step purchase flow: check balance, propose, wait for approval, execute.",
+    {
+      merchant: z5.string().describe("Merchant name"),
+      amount: z5.string().describe('Purchase amount in USD (e.g. "29.99")'),
+      description: z5.string().describe("What is being purchased"),
+      url: z5.string().describe("Product or checkout URL")
+    },
+    async ({ merchant, amount, description, url }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              `I need to purchase from ${merchant}.`,
+              "",
+              "Follow these steps exactly:",
+              "",
+              "1. Call agentpay_check_balance to verify sufficient funds",
+              `2. Call agentpay_propose_purchase with:`,
+              `   - merchant: "${merchant}"`,
+              `   - amount: ${amount}`,
+              `   - description: "${description}"`,
+              `   - url: "${url}"`,
+              "3. Tell me the transaction ID and that I need to approve it",
+              "4. Call agentpay_wait_for_approval with the transaction ID",
+              "5. Once approved, call agentpay_execute_purchase",
+              "6. Call agentpay_get_receipt to confirm",
+              "",
+              "If any step fails, stop and explain what went wrong."
+            ].join("\n")
+          }
+        }
+      ]
+    })
+  );
+}
+var init_buy = __esm({
+  "src/prompts/buy.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/prompts/budget-check.ts
+function registerBudgetCheckPrompt(server) {
+  server.prompt(
+    "budget-check",
+    "Check current balance, spending limits, and pending transactions.",
+    {},
+    async () => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "Check my AgentPay budget status:",
+              "",
+              "1. Call agentpay_check_balance to get current balance and limits",
+              "2. Call agentpay_list_pending to see any pending transactions",
+              "3. Summarize:",
+              "   - Available balance",
+              "   - Per-transaction limit",
+              "   - Total budget and amount spent",
+              "   - Number of pending transactions (if any)"
+            ].join("\n")
+          }
+        }
+      ]
+    })
+  );
+}
+var init_budget_check = __esm({
+  "src/prompts/budget-check.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/prompts/purchase-status.ts
+import { z as z6 } from "zod";
+function registerPurchaseStatusPrompt(server) {
+  server.prompt(
+    "purchase-status",
+    "Review recent transactions and their receipts.",
+    {
+      limit: z6.string().optional().describe("Number of recent transactions to show (default 5)")
+    },
+    async ({ limit }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              `Show me the status of my recent AgentPay transactions (last ${limit ?? "5"}):`,
+              "",
+              "1. Call agentpay_status to get recent transactions",
+              "2. For each completed transaction, call agentpay_get_receipt",
+              "3. Present a summary table with:",
+              "   - Transaction ID",
+              "   - Merchant",
+              "   - Amount",
+              "   - Status",
+              "   - Confirmation ID (if completed)"
+            ].join("\n")
+          }
+        }
+      ]
+    })
+  );
+}
+var init_purchase_status = __esm({
+  "src/prompts/purchase-status.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/prompts/index.ts
+function registerPrompts(server) {
+  registerBuyPrompt(server);
+  registerBudgetCheckPrompt(server);
+  registerPurchaseStatusPrompt(server);
+}
+var init_prompts = __esm({
+  "src/prompts/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_buy();
+    init_budget_check();
+    init_purchase_status();
+  }
+});
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { AgentPay as AgentPay3 } from "@useagentpay/sdk";
+function createServer(config) {
+  const server = new McpServer({
+    name: "agentpay",
+    version: true ? "0.1.4" : "0.0.0"
+  });
+  const ap = new AgentPay3({
+    home: config.home,
+    executor: config.executor
+  });
+  registerTools(server, ap, config);
+  registerResources(server, ap);
+  registerPrompts(server);
+  return server;
+}
+var init_server = __esm({
+  "src/server.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_tools();
+    init_resources();
+    init_prompts();
+  }
+});
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { realpathSync } from "fs";
+async function startServer(overrides) {
+  const config = loadConfig(overrides);
+  const server = createServer(config);
+  if (config.http) {
+    const { createServer: createHttpServer } = await import("http");
+    const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => crypto.randomUUID() });
+    await server.connect(transport);
+    const httpServer = createHttpServer((req, res) => {
+      transport.handleRequest(req, res);
+    });
+    const port = parseInt(process.env.MCP_HTTP_PORT ?? "3100", 10);
+    httpServer.listen(port, () => {
+      console.error(`AgentPay MCP server listening on http://localhost:${port}`);
+    });
+    const shutdown = () => {
+      httpServer.close();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } else {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    const shutdown = async () => {
+      await server.close();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  }
+}
+var isDirectRun;
+var init_src = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_server();
+    init_config();
+    init_server();
+    init_config();
+    isDirectRun = false;
+    try {
+      const thisFile = fileURLToPath2(import.meta.url);
+      isDirectRun = !!process.argv[1] && realpathSync(process.argv[1]) === thisFile;
+    } catch {
+    }
+    if (isDirectRun) {
+      const httpFlag = process.argv.includes("--http");
+      startServer({ http: httpFlag }).catch((err) => {
+        console.error("Failed to start MCP server:", err);
+        process.exit(1);
+      });
+    }
+  }
+});
+
+// src/commands/serve.ts
+var serve_exports = {};
+__export(serve_exports, {
+  serveCommand: () => serveCommand
+});
+async function serveCommand(options) {
+  await startServer({ http: options.http });
+}
+var init_serve = __esm({
+  "src/commands/serve.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_src();
+  }
+});
+
+// src/cli.ts
+init_esm_shims();
+import { Command } from "commander";
+var VERSION = true ? "0.1.4" : "0.0.0";
+var program = new Command();
+program.name("agentpay").description("AgentPay \u2013 MCP server & CLI for AI agent payments").version(VERSION);
+program.command("init").description("Initialize AgentPay in the current directory").action(async () => {
+  const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+  initCommand2();
+});
+program.command("setup").description("Set up AgentPay with your billing credentials").action(async () => {
+  const { setupCommand: setupCommand2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+  await setupCommand2();
+});
+program.command("budget").description("View current spending budget (configure via dashboard)").action(async () => {
+  const { budgetCommand: budgetCommand2 } = await Promise.resolve().then(() => (init_budget(), budget_exports));
+  budgetCommand2();
+});
+program.command("pending").description("List pending purchase proposals").action(async () => {
+  const { pendingCommand: pendingCommand2 } = await Promise.resolve().then(() => (init_pending(), pending_exports));
+  pendingCommand2();
+});
+program.command("propose").description("Propose a purchase (creates a pending transaction)").requiredOption("--merchant <name>", "Merchant name").requiredOption("--amount <amount>", "Purchase amount in USD").requiredOption("--description <desc>", "Purchase description").requiredOption("--url <url>", "Product/checkout URL").action(async (options) => {
+  const { proposeCommand: proposeCommand2 } = await Promise.resolve().then(() => (init_propose(), propose_exports));
+  proposeCommand2(options);
+});
+program.command("approve <txId>").description("Approve a pending purchase").action(async (txId) => {
+  const { approveCommand: approveCommand2 } = await Promise.resolve().then(() => (init_approve(), approve_exports));
+  await approveCommand2(txId);
+});
+program.command("reject <txId>").description("Reject a pending purchase").option("--reason <reason>", "Reason for rejection").action(async (txId, options) => {
+  const { rejectCommand: rejectCommand2 } = await Promise.resolve().then(() => (init_reject(), reject_exports));
+  rejectCommand2(txId, options);
+});
+program.command("status").description("Show wallet status and recent transactions").action(async () => {
+  const { statusCommand: statusCommand2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+  statusCommand2();
+});
+program.command("history").description("Show full transaction history").action(async () => {
+  const { historyCommand: historyCommand2 } = await Promise.resolve().then(() => (init_history(), history_exports));
+  historyCommand2();
+});
+program.command("reset").description("Delete all AgentPay data").action(async () => {
+  const { resetCommand: resetCommand2 } = await Promise.resolve().then(() => (init_reset(), reset_exports));
+  await resetCommand2();
+});
+program.command("dashboard").description("Open the AgentPay dashboard in your browser").option("--port <port>", "Port for dashboard server", "3141").action(async (options) => {
+  const { dashboardCommand: dashboardCommand2 } = await Promise.resolve().then(() => (init_dashboard(), dashboard_exports));
+  await dashboardCommand2(options);
+});
+program.command("serve").description("Start AgentPay MCP server").option("--http", "Use HTTP transport instead of stdio").action(async (options) => {
+  const { serveCommand: serveCommand2 } = await Promise.resolve().then(() => (init_serve(), serve_exports));
+  await serveCommand2(options);
+});
+program.parse();
+//# sourceMappingURL=cli.js.map