@sly_ai/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1129 @@
+#!/usr/bin/env node
+import {
+  createClient
+} from "./chunk-RYX22XBE.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/utils/output.ts
+function output(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function error(message) {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}
+
+// src/commands/accounts.ts
+function registerAccountsCommands(program2) {
+  const cmd = program2.command("accounts").description("Manage accounts (entities in the payment ledger)");
+  cmd.command("list").description("List accounts").option("--status <status>", "Filter by status (active, inactive, suspended)").option("--type <type>", "Filter by type (person, business)").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const params = new URLSearchParams();
+      if (opts.status) params.set("status", opts.status);
+      if (opts.type) params.set("type", opts.type);
+      const qs = params.toString();
+      const result = await sly.request(`/v1/accounts${qs ? `?${qs}` : ""}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("create").description("Create a new account").requiredOption("--name <name>", "Account holder name").requiredOption("--type <type>", "Account type (person, business)").option("--email <email>", "Email address").option("--metadata <json>", "Metadata as JSON string").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = { name: opts.name, type: opts.type };
+      if (opts.email) body.email = opts.email;
+      if (opts.metadata) body.metadata = JSON.parse(opts.metadata);
+      const result = await sly.request("/v1/accounts", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("get <id>").description("Get account details").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/accounts/${id}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("update <id>").description("Update an account").option("--name <name>", "New name").option("--email <email>", "New email").option("--metadata <json>", "Metadata as JSON string").action(async (id, opts) => {
+    try {
+      const sly = createClient();
+      const body = {};
+      if (opts.name) body.name = opts.name;
+      if (opts.email) body.email = opts.email;
+      if (opts.metadata) body.metadata = JSON.parse(opts.metadata);
+      const result = await sly.request(`/v1/accounts/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/agents.ts
+function registerAgentsCommands(program2) {
+  const cmd = program2.command("agents").description("Manage AI agents");
+  cmd.command("create").description("Register a new AI agent under a business account").requiredOption("--account-id <accountId>", "UUID of the parent business account").requiredOption("--name <name>", "Name for the agent").option("--description <description>", "Description of what the agent does").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        accountId: opts.accountId,
+        name: opts.name
+      };
+      if (opts.description) body.description = opts.description;
+      const result = await sly.request("/v1/agents", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("get <id>").description("Get agent details").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/agents/${id}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("delete <id>").description("Delete an agent").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/agents/${id}`, { method: "DELETE" });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("verify <id>").description("Verify an agent at a KYA tier").requiredOption("--tier <tier>", "KYA verification tier (1, 2, or 3)", parseInt).action(async (id, opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/agents/${id}/verify`, {
+        method: "POST",
+        body: JSON.stringify({ tier: opts.tier })
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("limits <id>").description("Get spending limits and current usage for an agent").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/agents/${id}/limits`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("transactions <id>").description("Get transaction history for an agent").option("--limit <limit>", "Max results per page", parseInt).option("--offset <offset>", "Offset for pagination", parseInt).option("--from <from>", "Filter from date (ISO 8601)").option("--to <to>", "Filter to date (ISO 8601)").action(async (id, opts) => {
+    try {
+      const sly = createClient();
+      const params = new URLSearchParams();
+      if (opts.limit) params.set("limit", String(opts.limit));
+      if (opts.offset) params.set("offset", String(opts.offset));
+      if (opts.from) params.set("from", opts.from);
+      if (opts.to) params.set("to", opts.to);
+      const qs = params.toString();
+      const result = await sly.request(`/v1/agents/${id}/transactions${qs ? `?${qs}` : ""}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/wallets.ts
+function registerWalletsCommands(program2) {
+  const cmd = program2.command("wallets").description("Manage wallets");
+  cmd.command("list").description("List wallets").option("--status <status>", "Filter by status (active, frozen, depleted)").option("--owner-account-id <id>", "Filter by owner account UUID").option("--managed-by-agent-id <id>", "Filter by managing agent UUID").option("--page <page>", "Page number", parseInt).option("--limit <limit>", "Results per page", parseInt).action(async (opts) => {
+    try {
+      const sly = createClient();
+      const params = new URLSearchParams();
+      if (opts.status) params.set("status", opts.status);
+      if (opts.ownerAccountId) params.set("owner_account_id", opts.ownerAccountId);
+      if (opts.managedByAgentId) params.set("managed_by_agent_id", opts.managedByAgentId);
+      if (opts.page) params.set("page", String(opts.page));
+      if (opts.limit) params.set("limit", String(opts.limit));
+      const qs = params.toString();
+      const result = await sly.request(`/v1/wallets${qs ? `?${qs}` : ""}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("create").description("Create a new wallet for an account").requiredOption("--account-id <accountId>", "UUID of the owning account").option("--name <name>", "Human-readable wallet name").option("--blockchain <blockchain>", "Blockchain network (base, eth, polygon, avax, sol)").option("--wallet-type <walletType>", "Wallet type (internal, circle_custodial, circle_mpc)").option("--currency <currency>", "Wallet currency (USDC, EURC)").option("--managed-by-agent-id <agentId>", "UUID of managing agent").option("--purpose <purpose>", "Purpose of the wallet").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = { accountId: opts.accountId };
+      if (opts.name) body.name = opts.name;
+      if (opts.blockchain) body.blockchain = opts.blockchain;
+      if (opts.walletType) body.walletType = opts.walletType;
+      if (opts.currency) body.currency = opts.currency;
+      if (opts.managedByAgentId) body.managedByAgentId = opts.managedByAgentId;
+      if (opts.purpose) body.purpose = opts.purpose;
+      const result = await sly.request("/v1/wallets", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("get <id>").description("Get wallet details").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/wallets/${id}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("balance <id>").description("Get wallet balance").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/wallets/${id}/balance`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("fund <id>").description("Add test funds to a wallet (sandbox only)").requiredOption("--amount <amount>", "Amount of test funds to add", parseFloat).option("--currency <currency>", "Currency (USDC, EURC)").option("--reference <reference>", "Reference note").action(async (id, opts) => {
+    try {
+      const sly = createClient();
+      const body = { amount: opts.amount };
+      if (opts.currency) body.currency = opts.currency;
+      if (opts.reference) body.reference = opts.reference;
+      const result = await sly.request(`/v1/wallets/${id}/test-fund`, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("deposit <id>").description("Deposit funds into a wallet").requiredOption("--amount <amount>", "Amount to deposit", parseFloat).requiredOption("--from-account-id <accountId>", "UUID of the source account").option("--reference <reference>", "Reference note").action(async (id, opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        amount: opts.amount,
+        fromAccountId: opts.fromAccountId
+      };
+      if (opts.reference) body.reference = opts.reference;
+      const result = await sly.request(`/v1/wallets/${id}/deposit`, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("withdraw <id>").description("Withdraw funds from a wallet").requiredOption("--amount <amount>", "Amount to withdraw", parseFloat).requiredOption("--destination-account-id <accountId>", "UUID of the destination account").option("--reference <reference>", "Reference note").action(async (id, opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        amount: opts.amount,
+        destinationAccountId: opts.destinationAccountId
+      };
+      if (opts.reference) body.reference = opts.reference;
+      const result = await sly.request(`/v1/wallets/${id}/withdraw`, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/settlement.ts
+function registerSettlementCommands(program2) {
+  const cmd = program2.command("settlement").description("Manage settlements and FX quotes");
+  cmd.command("quote").description("Get a settlement quote with FX rates and fees").requiredOption("--from-currency <currency>", "Source currency (USD, BRL, MXN, USDC)").requiredOption("--to-currency <currency>", "Destination currency (USD, BRL, MXN, USDC)").requiredOption("--amount <amount>", "Amount to convert").option("--rail <rail>", "Settlement rail (pix, spei, wire, usdc)").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const quote = await sly.getSettlementQuote({
+        fromCurrency: opts.fromCurrency,
+        toCurrency: opts.toCurrency,
+        amount: opts.amount,
+        rail: opts.rail
+      });
+      output(quote);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("create").description("Execute a settlement using a quote").requiredOption("--quote-id <quoteId>", "Quote ID from settlement quote").requiredOption("--destination-account-id <accountId>", "Destination account ID").option("--metadata <json>", "Optional metadata as JSON string").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        quoteId: opts.quoteId,
+        destinationAccountId: opts.destinationAccountId
+      };
+      if (opts.metadata) body.metadata = JSON.parse(opts.metadata);
+      const settlement = await sly.createSettlement(body);
+      output(settlement);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("status <id>").description("Check the status of a settlement").action(async (id) => {
+    try {
+      const sly = createClient();
+      const settlement = await sly.getSettlement(id);
+      output(settlement);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/x402.ts
+function registerX402Commands(program2) {
+  const cmd = program2.command("x402").description("x402 micropayment endpoints");
+  cmd.command("endpoints").description("List x402 payment endpoints").option("--status <status>", "Filter by status (active, paused, disabled)").option("--account-id <id>", "Filter by account UUID").option("--page <page>", "Page number", parseInt).option("--limit <limit>", "Results per page", parseInt).action(async (opts) => {
+    try {
+      const sly = createClient();
+      const params = new URLSearchParams();
+      if (opts.status) params.set("status", opts.status);
+      if (opts.accountId) params.set("account_id", opts.accountId);
+      if (opts.page) params.set("page", String(opts.page));
+      if (opts.limit) params.set("limit", String(opts.limit));
+      const qs = params.toString();
+      const result = await sly.request(`/v1/x402/endpoints${qs ? `?${qs}` : ""}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("get-endpoint <id>").description("Get x402 endpoint details").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/x402/endpoints/${id}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("create-endpoint").description("Register an x402 payment endpoint").requiredOption("--name <name>", "Endpoint name").requiredOption("--path <path>", "API path (must start with /)").requiredOption("--method <method>", "HTTP method (GET, POST, PUT, DELETE, PATCH, ANY)").requiredOption("--account-id <accountId>", "UUID of the account receiving payments").requiredOption("--base-price <price>", "Price per request in token units", parseFloat).option("--currency <currency>", "Payment currency (USDC, EURC)").option("--description <description>", "What this endpoint provides").option("--webhook-url <url>", "URL to notify on payment").option("--network <network>", "Blockchain network").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        name: opts.name,
+        path: opts.path,
+        method: opts.method,
+        accountId: opts.accountId,
+        basePrice: opts.basePrice
+      };
+      if (opts.currency) body.currency = opts.currency;
+      if (opts.description) body.description = opts.description;
+      if (opts.webhookUrl) body.webhookUrl = opts.webhookUrl;
+      if (opts.network) body.network = opts.network;
+      const result = await sly.request("/v1/x402/endpoints", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("pay").description("Make an x402 micropayment to a paid endpoint").requiredOption("--endpoint-id <endpointId>", "UUID of the x402 endpoint to pay").requiredOption("--wallet-id <walletId>", "UUID of the wallet to pay from").requiredOption("--amount <amount>", "Payment amount", parseFloat).requiredOption("--currency <currency>", "Payment currency (USDC, EURC)").requiredOption("--method <method>", "HTTP method of the request being paid for").requiredOption("--path <path>", "Path of the request being paid for").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request("/v1/x402/payments", {
+        method: "POST",
+        body: JSON.stringify({
+          endpointId: opts.endpointId,
+          walletId: opts.walletId,
+          amount: opts.amount,
+          currency: opts.currency,
+          method: opts.method,
+          path: opts.path
+        })
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("verify").description("Verify an x402 payment").option("--jwt <jwt>", "JWT payment proof for fast verification").option("--request-id <requestId>", "Request ID for database verification").option("--transfer-id <transferId>", "Transfer ID for database verification").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {};
+      if (opts.jwt) body.jwt = opts.jwt;
+      if (opts.requestId) body.requestId = opts.requestId;
+      if (opts.transferId) body.transferId = opts.transferId;
+      const result = await sly.request("/v1/x402/verify", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/ap2.ts
+function registerAP2Commands(program2) {
+  const cmd = program2.command("ap2").description("AP2 (Agent-to-Agent Protocol) mandate-based payments");
+  cmd.command("mandates").description("List mandates").option("--status <status>", "Filter by status (active, completed, cancelled, expired)").option("--agent-id <agentId>", "Filter by agent ID").option("--account-id <accountId>", "Filter by account ID").option("--limit <limit>", "Max results", parseInt).action(async (opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.ap2.listMandates({
+        status: opts.status,
+        agent_id: opts.agentId,
+        account_id: opts.accountId,
+        limit: opts.limit
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("get <mandateId>").description("Get mandate details with execution history").action(async (mandateId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.ap2.getMandate(mandateId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("create").description("Create a spending mandate for an agent").requiredOption("--mandate-id <mandateId>", "Unique mandate identifier").requiredOption("--agent-id <agentId>", "UUID of the agent").requiredOption("--account-id <accountId>", "UUID of the funding account").requiredOption("--authorized-amount <amount>", "Maximum spending amount", parseFloat).option("--currency <currency>", "Currency (default: USD)").option("--mandate-type <type>", "Type: intent, cart, or payment (default: payment)").option("--description <description>", "Human-readable description").option("--expires-at <date>", "ISO 8601 expiration timestamp").option("--metadata <json>", "Metadata as JSON string").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        mandate_id: opts.mandateId,
+        agent_id: opts.agentId,
+        account_id: opts.accountId,
+        authorized_amount: opts.authorizedAmount
+      };
+      if (opts.currency) body.currency = opts.currency;
+      if (opts.mandateType) body.mandate_type = opts.mandateType;
+      if (opts.description) body.description = opts.description;
+      if (opts.expiresAt) body.expires_at = opts.expiresAt;
+      if (opts.metadata) body.metadata = JSON.parse(opts.metadata);
+      const result = await sly.ap2.createMandate(body);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("execute <mandateId>").description("Execute a payment against a mandate").requiredOption("--amount <amount>", "Amount to pay", parseFloat).option("--currency <currency>", "Currency").option("--description <description>", "Description of this payment").action(async (mandateId, opts) => {
+    try {
+      const sly = createClient();
+      const body = { amount: opts.amount };
+      if (opts.currency) body.currency = opts.currency;
+      if (opts.description) body.description = opts.description;
+      const result = await sly.ap2.executeMandate(mandateId, body);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("cancel <mandateId>").description("Cancel an active mandate").action(async (mandateId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.ap2.cancelMandate(mandateId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("update <mandateId>").description("Update a mandate").option("--authorized-amount <amount>", "New authorized amount", parseFloat).option("--status <status>", "New status").option("--expires-at <date>", "New expiration (ISO 8601)").option("--description <description>", "Updated description").option("--metadata <json>", "Updated metadata as JSON string").action(async (mandateId, opts) => {
+    try {
+      const sly = createClient();
+      const body = {};
+      if (opts.authorizedAmount !== void 0) body.authorized_amount = opts.authorizedAmount;
+      if (opts.status) body.status = opts.status;
+      if (opts.expiresAt) body.expires_at = opts.expiresAt;
+      if (opts.description) body.description = opts.description;
+      if (opts.metadata) body.metadata = JSON.parse(opts.metadata);
+      const result = await sly.request(`/v1/ap2/mandates/${mandateId}`, {
+        method: "PATCH",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/acp.ts
+function registerACPCommands(program2) {
+  const cmd = program2.command("acp").description("ACP (Agentic Commerce Protocol) checkout-based payments");
+  cmd.command("checkouts").description("List ACP checkouts").option("--status <status>", "Filter by status (pending, completed, cancelled, expired)").option("--agent-id <agentId>", "Filter by agent ID").option("--merchant-id <merchantId>", "Filter by merchant ID").option("--limit <limit>", "Max results", parseInt).action(async (opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.acp.listCheckouts({
+        status: opts.status,
+        agent_id: opts.agentId,
+        merchant_id: opts.merchantId,
+        limit: opts.limit
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("get <checkoutId>").description("Get checkout details").action(async (checkoutId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.acp.getCheckout(checkoutId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("create").description("Create a checkout session").requiredOption("--checkout-id <checkoutId>", "Unique checkout identifier").requiredOption("--agent-id <agentId>", "UUID of the agent").requiredOption("--merchant-id <merchantId>", "Merchant identifier").requiredOption("--items <json>", "Items as JSON array").option("--account-id <accountId>", "UUID of the funding account").option("--tax-amount <amount>", "Tax amount", parseFloat).option("--shipping-amount <amount>", "Shipping amount", parseFloat).option("--payment-method <method>", "Payment method").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        checkout_id: opts.checkoutId,
+        agent_id: opts.agentId,
+        merchant_id: opts.merchantId,
+        items: JSON.parse(opts.items)
+      };
+      if (opts.accountId) body.account_id = opts.accountId;
+      if (opts.taxAmount !== void 0) body.tax_amount = opts.taxAmount;
+      if (opts.shippingAmount !== void 0) body.shipping_amount = opts.shippingAmount;
+      if (opts.paymentMethod) body.payment_method = opts.paymentMethod;
+      const result = await sly.acp.createCheckout(body);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("complete <checkoutId>").description("Complete and pay for a checkout").option("--shared-payment-token <token>", "Shared payment token (auto-generated in sandbox)").option("--payment-method <method>", "Payment method").action(async (checkoutId, opts) => {
+    try {
+      const sly = createClient();
+      const body = {};
+      if (opts.sharedPaymentToken) body.shared_payment_token = opts.sharedPaymentToken;
+      if (opts.paymentMethod) body.payment_method = opts.paymentMethod;
+      const result = await sly.acp.completeCheckout(checkoutId, body);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("cancel <checkoutId>").description("Cancel a checkout").action(async (checkoutId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.acp.cancelCheckout(checkoutId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/ucp.ts
+function registerUCPCommands(program2) {
+  const cmd = program2.command("ucp").description("UCP (Universal Commerce Protocol) operations");
+  cmd.command("discover <merchantUrl>").description("Discover a UCP merchant's capabilities").action(async (merchantUrl) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request("/v1/ucp/discover", {
+        method: "POST",
+        body: JSON.stringify({ merchantUrl })
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("checkouts").description("List UCP checkout sessions").option("--status <status>", "Filter by status").option("--agent-id <agentId>", "Filter by agent ID").option("--page <page>", "Page number", parseInt).option("--limit <limit>", "Results per page", parseInt).action(async (opts) => {
+    try {
+      const sly = createClient();
+      const params = new URLSearchParams();
+      if (opts.status) params.set("status", opts.status);
+      if (opts.agentId) params.set("agent_id", opts.agentId);
+      if (opts.page) params.set("page", String(opts.page));
+      if (opts.limit) params.set("limit", String(opts.limit));
+      const qs = params.toString();
+      const result = await sly.request(`/v1/ucp/checkouts${qs ? `?${qs}` : ""}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("create-checkout").description("Create a UCP checkout session").requiredOption("--currency <currency>", "ISO 4217 pricing currency (e.g., USD)").requiredOption("--line-items <json>", "Line items as JSON array").option("--buyer <json>", "Buyer info as JSON").option("--shipping-address <json>", "Shipping address as JSON").option("--checkout-type <type>", "Checkout type (physical, digital, service)").option("--agent-id <agentId>", "Agent ID to attribute this checkout to").option("--metadata <json>", "Custom metadata as JSON").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        currency: opts.currency,
+        line_items: JSON.parse(opts.lineItems)
+      };
+      if (opts.buyer) body.buyer = JSON.parse(opts.buyer);
+      if (opts.shippingAddress) body.shipping_address = JSON.parse(opts.shippingAddress);
+      if (opts.checkoutType) body.checkout_type = opts.checkoutType;
+      if (opts.agentId) body.agent_id = opts.agentId;
+      if (opts.metadata) body.metadata = JSON.parse(opts.metadata);
+      const result = await sly.request("/v1/ucp/checkouts", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("get-checkout <id>").description("Get UCP checkout details").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/ucp/checkouts/${id}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("complete-checkout <id>").description("Complete a UCP checkout").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/ucp/checkouts/${id}/complete`, {
+        method: "POST"
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("cancel-checkout <id>").description("Cancel a UCP checkout session").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/ucp/checkouts/${id}/cancel`, {
+        method: "POST"
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("add-instrument <checkoutId>").description("Add a payment instrument to a UCP checkout").requiredOption("--instrument-id <id>", "Unique instrument identifier").requiredOption("--handler <handler>", "Payment handler (e.g., sly)").requiredOption("--type <type>", "Instrument type (e.g., usdc)").option("--last4 <last4>", "Last 4 digits").option("--brand <brand>", "Brand name").action(async (checkoutId, opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        id: opts.instrumentId,
+        handler: opts.handler,
+        type: opts.type
+      };
+      if (opts.last4) body.last4 = opts.last4;
+      if (opts.brand) body.brand = opts.brand;
+      const result = await sly.request(`/v1/ucp/checkouts/${checkoutId}/instruments`, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("orders").description("List UCP orders").option("--status <status>", "Filter by order status").option("--agent-id <agentId>", "Filter by agent ID").option("--page <page>", "Page number", parseInt).option("--limit <limit>", "Results per page", parseInt).action(async (opts) => {
+    try {
+      const sly = createClient();
+      const params = new URLSearchParams();
+      if (opts.status) params.set("status", opts.status);
+      if (opts.agentId) params.set("agent_id", opts.agentId);
+      if (opts.page) params.set("page", String(opts.page));
+      if (opts.limit) params.set("limit", String(opts.limit));
+      const qs = params.toString();
+      const result = await sly.request(`/v1/ucp/orders${qs ? `?${qs}` : ""}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("get-order <id>").description("Get UCP order details").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/ucp/orders/${id}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("update-order-status <orderId>").description("Update UCP order status").requiredOption("--status <status>", "New order status (processing, shipped, delivered)").action(async (orderId, opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/ucp/orders/${orderId}/status`, {
+        method: "PUT",
+        body: JSON.stringify({ status: opts.status })
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("cancel-order <orderId>").description("Cancel a UCP order").option("--reason <reason>", "Cancellation reason").action(async (orderId, opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/ucp/orders/${orderId}/cancel`, {
+        method: "POST",
+        body: JSON.stringify({ reason: opts.reason })
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("add-event <orderId>").description("Record a fulfillment event on a UCP order").requiredOption("--type <type>", "Event type (shipped, in_transit, out_for_delivery, delivered, returned)").requiredOption("--description <description>", "Event description").option("--tracking-number <trackingNumber>", "Tracking number").option("--carrier <carrier>", "Shipping carrier").action(async (orderId, opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        type: opts.type,
+        description: opts.description
+      };
+      if (opts.trackingNumber) body.tracking_number = opts.trackingNumber;
+      if (opts.carrier) body.carrier = opts.carrier;
+      const result = await sly.request(`/v1/ucp/orders/${orderId}/events`, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/mpp.ts
+function registerMPPCommands(program2) {
+  const cmd = program2.command("mpp").description("MPP (Machine Payments Protocol) sessions and payments");
+  cmd.command("sessions").description("List MPP sessions").option("--agent-id <agentId>", "Filter by agent ID").option("--status <status>", "Filter by status (active, closed, expired, exhausted)").option("--limit <limit>", "Results per page", parseInt).option("--offset <offset>", "Offset for pagination", parseInt).action(async (opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.mpp.listSessions({
+        agent_id: opts.agentId,
+        status: opts.status,
+        limit: opts.limit,
+        offset: opts.offset
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("get-session <id>").description("Get MPP session details with voucher history").action(async (id) => {
+    try {
+      const sly = createClient();
+      const result = await sly.mpp.getSession(id);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("open").description("Open a streaming MPP payment session").requiredOption("--service-url <url>", "URL of the service").requiredOption("--deposit-amount <amount>", "Initial deposit amount", parseFloat).requiredOption("--agent-id <agentId>", "UUID of the agent").requiredOption("--wallet-id <walletId>", "UUID of the wallet").option("--max-budget <amount>", "Maximum total budget", parseFloat).option("--currency <currency>", "Currency (default: USDC)").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        service_url: opts.serviceUrl,
+        deposit_amount: opts.depositAmount,
+        agent_id: opts.agentId,
+        wallet_id: opts.walletId
+      };
+      if (opts.maxBudget !== void 0) body.max_budget = opts.maxBudget;
+      if (opts.currency) body.currency = opts.currency;
+      const result = await sly.mpp.openSession(body);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("pay").description("Make a one-shot MPP payment to a service").requiredOption("--service-url <url>", "URL of the service to pay").requiredOption("--amount <amount>", "Payment amount", parseFloat).requiredOption("--agent-id <agentId>", "UUID of the agent making the payment").option("--wallet-id <walletId>", "UUID of the wallet to pay from").option("--currency <currency>", "Currency (default: USDC)").option("--intent <intent>", "Description of what the payment is for").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        service_url: opts.serviceUrl,
+        amount: opts.amount,
+        agent_id: opts.agentId
+      };
+      if (opts.walletId) body.wallet_id = opts.walletId;
+      if (opts.currency) body.currency = opts.currency;
+      if (opts.intent) body.intent = opts.intent;
+      const result = await sly.mpp.pay(body);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("close <sessionId>").description("Close an active MPP session").action(async (sessionId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.mpp.closeSession(sessionId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("transfers").description("List MPP payment transfers").option("--service-url <url>", "Filter by service URL").option("--session-id <id>", "Filter by session ID").option("--limit <limit>", "Results per page", parseInt).option("--offset <offset>", "Offset for pagination", parseInt).action(async (opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.mpp.listTransfers({
+        service_url: opts.serviceUrl,
+        session_id: opts.sessionId,
+        limit: opts.limit,
+        offset: opts.offset
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("verify-receipt <receiptId>").description("Verify an MPP payment receipt").action(async (receiptId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.mpp.verifyReceipt(receiptId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/a2a.ts
+function registerA2ACommands(program2) {
+  const cmd = program2.command("a2a").description("A2A (Agent-to-Agent Protocol) task management");
+  cmd.command("discover <agentId>").description("Discover an agent's capabilities via its Agent Card").action(async (agentId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.a2a.discover(agentId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("send").description("Send a message to an A2A agent").requiredOption("--agent-id <agentId>", "Local Sly agent ID").requiredOption("--message <message>", "Text message to send to the agent").option("--context-id <contextId>", "Context ID for multi-turn conversations").option("--skill-id <skillId>", "Skill ID to target").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.a2a.sendMessage(opts.agentId, {
+        message: opts.message,
+        contextId: opts.contextId,
+        skillId: opts.skillId
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("get-task").description("Get the status and details of an A2A task").requiredOption("--agent-id <agentId>", "Agent ID").requiredOption("--task-id <taskId>", "Task ID").option("--history-length <length>", "Number of history items to include", parseInt).action(async (opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.a2a.getTask(opts.agentId, opts.taskId, opts.historyLength);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("tasks").description("List A2A tasks").option("--agent-id <agentId>", "Filter by agent ID").option("--state <state>", "Filter by state (submitted, working, input-required, completed, failed, canceled, rejected)").option("--direction <direction>", "Filter by direction (inbound, outbound)").option("--limit <limit>", "Results per page", parseInt).option("--page <page>", "Page number", parseInt).action(async (opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.a2a.listTasks({
+        agentId: opts.agentId,
+        state: opts.state,
+        direction: opts.direction,
+        limit: opts.limit,
+        page: opts.page
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("respond <taskId>").description("Respond to a task in input-required state").requiredOption("--message <message>", "Response message").action(async (taskId, opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.a2a.respond(taskId, opts.message);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("cancel").description("Cancel an A2A task").requiredOption("--agent-id <agentId>", "Agent ID").requiredOption("--task-id <taskId>", "Task ID").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.a2a.cancelTask(opts.agentId, opts.taskId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/agent-wallets.ts
+function registerAgentWalletsCommands(program2) {
+  const cmd = program2.command("agent-wallets").description("Agent wallet policies, exposures, and governance");
+  cmd.command("get <agentId>").description("Get agent wallet details including balance and spending policy").action(async (agentId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.agentWallets.getWallet(agentId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("evaluate-policy <agentId>").description("Evaluate contract policy for an agent payment (dry-run)").requiredOption("--amount <amount>", "Payment amount to evaluate", parseFloat).option("--currency <currency>", "Currency (default: USDC)").option("--action-type <type>", "Action type (payment, escrow_create, escrow_release, contract_sign, negotiation_check, counterparty_check)").option("--contract-type <type>", "Contract type").option("--counterparty-agent-id <id>", "UUID of the counterparty agent").option("--counterparty-address <addr>", "Wallet address of external counterparty").action(async (agentId, opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.agentWallets.evaluatePolicy(agentId, {
+        amount: opts.amount,
+        currency: opts.currency,
+        actionType: opts.actionType || "negotiation_check",
+        contractType: opts.contractType,
+        counterpartyAgentId: opts.counterpartyAgentId,
+        counterpartyAddress: opts.counterpartyAddress
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("exposures <agentId>").description("List per-counterparty exposure windows for an agent wallet").action(async (agentId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.agentWallets.getExposures(agentId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("evaluations <agentId>").description("Get the policy evaluation audit log for an agent wallet").option("--page <page>", "Page number", parseInt).option("--limit <limit>", "Results per page", parseInt).action(async (agentId, opts) => {
+    try {
+      const sly = createClient();
+      const result = await sly.agentWallets.getEvaluations(agentId, {
+        page: opts.page,
+        limit: opts.limit
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("freeze <agentId>").description("Freeze an agent's wallet (disables all payments)").action(async (agentId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.agentWallets.freezeWallet(agentId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("unfreeze <agentId>").description("Unfreeze an agent's wallet").action(async (agentId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.agentWallets.unfreezeWallet(agentId);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("set-policy <agentId>").description("Set or update the spending and contract policy on an agent's wallet").option("--daily-spend-limit <amount>", "Daily spending limit", parseFloat).option("--monthly-spend-limit <amount>", "Monthly spending limit", parseFloat).option("--requires-approval-above <amount>", "Amount above which human approval is required", parseFloat).option("--approved-vendors <json>", "Approved vendor domains as JSON array").option("--contract-policy <json>", "Contract policy rules as JSON object").action(async (agentId, opts) => {
+    try {
+      const sly = createClient();
+      const policy = {};
+      if (opts.dailySpendLimit !== void 0) policy.dailySpendLimit = opts.dailySpendLimit;
+      if (opts.monthlySpendLimit !== void 0) policy.monthlySpendLimit = opts.monthlySpendLimit;
+      if (opts.requiresApprovalAbove !== void 0) policy.requiresApprovalAbove = opts.requiresApprovalAbove;
+      if (opts.approvedVendors) policy.approvedVendors = JSON.parse(opts.approvedVendors);
+      if (opts.contractPolicy) policy.contractPolicy = JSON.parse(opts.contractPolicy);
+      const result = await sly.agentWallets.setContractPolicy(agentId, policy);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/merchants.ts
+function registerMerchantsCommands(program2) {
+  const cmd = program2.command("merchants").description("Browse merchant catalogs");
+  cmd.command("list").description("List merchants with product catalogs").option("--type <type>", "Merchant type filter (e.g., restaurant, bar, hotel, retail)").option("--country <country>", "Country code filter (e.g., PA, CR)").option("--search <search>", "Search merchants by name").option("--limit <limit>", "Max results (default 50, max 100)", parseInt).action(async (opts) => {
+    try {
+      const sly = createClient();
+      const params = new URLSearchParams();
+      if (opts.type) params.set("type", opts.type);
+      if (opts.country) params.set("country", opts.country);
+      if (opts.search) params.set("search", opts.search);
+      if (opts.limit) params.set("limit", String(opts.limit));
+      const qs = params.toString();
+      const result = await sly.request(`/v1/ucp/merchants${qs ? `?${qs}` : ""}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("get <merchantId>").description("Get a merchant's full product catalog").action(async (merchantId) => {
+    try {
+      const sly = createClient();
+      const result = await sly.request(`/v1/ucp/merchants/${merchantId}`);
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/support.ts
+function registerSupportCommands(program2) {
+  const cmd = program2.command("support").description("Support and dispute management");
+  cmd.command("explain-rejection").description("Explain why a transaction was rejected").option("--error-code <code>", "Error code from the rejection").option("--transaction-id <id>", "UUID of the rejected transaction").option("--agent-id <id>", "UUID of the agent").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {};
+      if (opts.errorCode) body.error_code = opts.errorCode;
+      if (opts.transactionId) body.transaction_id = opts.transactionId;
+      if (opts.agentId) body.agent_id = opts.agentId;
+      const result = await sly.request("/v1/support/explain-rejection", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("request-limit-increase").description("Submit a request to increase an agent's spending limit").requiredOption("--agent-id <agentId>", "UUID of the agent").requiredOption("--limit-type <type>", "Which limit to increase (per_transaction, daily, monthly)").requiredOption("--requested-amount <amount>", "The new desired limit amount (USD)", parseFloat).requiredOption("--reason <reason>", "Business justification").option("--duration <duration>", "How long the increase should last (temporary_24h, temporary_7d, permanent)").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        agent_id: opts.agentId,
+        limit_type: opts.limitType,
+        requested_amount: opts.requestedAmount,
+        reason: opts.reason
+      };
+      if (opts.duration) body.duration = opts.duration;
+      const result = await sly.request("/v1/support/request-limit-increase", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("open-dispute").description("Open a dispute for a completed transaction").requiredOption("--transaction-id <id>", "UUID of the transaction").requiredOption("--reason <reason>", "Reason (service_not_received, duplicate_charge, unauthorized, amount_incorrect, quality_issue, other)").requiredOption("--description <description>", "Detailed description of the issue").option("--requested-resolution <resolution>", "Requested resolution (full_refund, partial_refund, credit, other)").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        transaction_id: opts.transactionId,
+        reason: opts.reason,
+        description: opts.description
+      };
+      if (opts.requestedResolution) body.requested_resolution = opts.requestedResolution;
+      const result = await sly.request("/v1/support/open-dispute", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("escalate").description("Escalate an issue to a human support operator").requiredOption("--reason <reason>", "Why this is being escalated (complex_issue, agent_requested, security_concern, policy_exception, bug_report)").requiredOption("--summary <summary>", "Summary of the issue").option("--agent-id <agentId>", "UUID of the agent").option("--priority <priority>", "Priority level (low, medium, high, critical)").action(async (opts) => {
+    try {
+      const sly = createClient();
+      const body = {
+        reason: opts.reason,
+        summary: opts.summary
+      };
+      if (opts.agentId) body.agent_id = opts.agentId;
+      if (opts.priority) body.priority = opts.priority;
+      const result = await sly.request("/v1/support/escalate", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/commands/env.ts
+function registerEnvCommands(program2) {
+  const cmd = program2.command("env").description("Environment management");
+  cmd.command("get").description("Show current environment info").action(() => {
+    try {
+      const apiKey = process.env.SLY_API_KEY;
+      if (!apiKey) {
+        error("SLY_API_KEY environment variable is not set");
+      }
+      const environment = apiKey.startsWith("pk_live_") ? "production" : "sandbox";
+      const masked = apiKey.slice(0, 12) + "***";
+      output({
+        environment,
+        apiKeyPrefix: masked,
+        apiUrl: process.env.SLY_API_URL || (environment === "production" ? "https://api.getsly.ai" : "https://sandbox.getsly.ai")
+      });
+    } catch (e) {
+      error(e.message);
+    }
+  });
+  cmd.command("switch <environment>").description("Show instructions for switching between sandbox and production").action((environment) => {
+    if (environment !== "sandbox" && environment !== "production") {
+      error('Environment must be "sandbox" or "production"');
+    }
+    const prefix = environment === "production" ? "pk_live_" : "pk_test_";
+    console.log(`To switch to ${environment}, set your API key:`);
+    console.log(`  export SLY_API_KEY=${prefix}your_key_here`);
+    if (environment === "production") {
+      console.log(`  export SLY_API_URL=https://api.getsly.ai`);
+    } else {
+      console.log(`  export SLY_API_URL=https://sandbox.getsly.ai`);
+    }
+  });
+  cmd.command("whoami").description("Get information about the current tenant/organization").action(async () => {
+    try {
+      const apiKey = process.env.SLY_API_KEY;
+      if (!apiKey) {
+        error("SLY_API_KEY environment variable is not set");
+      }
+      const { createClient: createClient2 } = await import("./auth-ET55P6PZ.js");
+      const sly = createClient2();
+      const result = await sly.request("/v1/context/whoami");
+      output(result);
+    } catch (e) {
+      error(e.message);
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command().name("sly").description("Sly CLI \u2014 the agentic economy platform").version("0.1.0");
+registerAccountsCommands(program);
+registerAgentsCommands(program);
+registerWalletsCommands(program);
+registerSettlementCommands(program);
+registerX402Commands(program);
+registerAP2Commands(program);
+registerACPCommands(program);
+registerUCPCommands(program);
+registerMPPCommands(program);
+registerA2ACommands(program);
+registerAgentWalletsCommands(program);
+registerMerchantsCommands(program);
+registerSupportCommands(program);
+registerEnvCommands(program);
+program.parse();