@caypo/canton-cli 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,14 @@
+
+> @caypo/canton-cli@0.1.0 build /Users/anil/Desktop/caypo/packages/cli
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /Users/anil/Desktop/caypo/packages/cli/tsup.config.ts
+CLI Target: es2022
+CLI Cleaning output folder
+ESM Build start
+ESM dist/index.js     16.09 KB
+ESM dist/index.js.map 32.52 KB
+ESM ⚡️ Build success in 11ms

package/.turbo/turbo-test.log

@@ -0,0 +1,12 @@
+
+> @caypo/canton-cli@0.1.0 test /Users/anil/Desktop/caypo/packages/cli
+> vitest run
+
+
+ RUN  v3.2.4 /Users/anil/Desktop/caypo/packages/cli
+
+No test files found, exiting with code 0
+
+include: **/*.{test,spec}.?(c|m)[jt]s?(x)
+exclude:  **/node_modules/**, **/dist/**, **/cypress/**, **/.{idea,git,cache,output,temp}/**, **/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*
+

package/README.md

@@ -0,0 +1,101 @@
+# @caypo/canton-cli
+
+**CLI for AI agent banking on [Canton Network](https://canton.network)**
+
+Manage your USDCx wallet, send payments, pay for APIs, and configure MCP server — all from the terminal.
+
+[![License](https://img.shields.io/badge/license-Apache--2.0%20%2F%20MIT-blue)](../../LICENSE-APACHE)
+
+## Install
+
+```bash
+npm install -g @caypo/canton-cli
+```
+
+## Commands
+
+```
+SETUP
+  caypo init                              Set up wallet (PIN, ledger URL, JWT, party)
+  caypo address                           Show your Canton party ID
+  caypo balance                           Show USDCx balance and holdings
+
+PAYMENTS
+  caypo send <amount> to <recipient>      Send USDCx to a party
+  caypo pay <url> [--max-price N]         Pay for API (auto 402 flow)
+
+SAFEGUARDS
+  caypo safeguards                        View spending limits
+  caypo safeguards set-tx-limit <amt>     Set per-transaction limit
+  caypo safeguards set-daily-limit <amt>  Set daily spending limit
+  caypo safeguards lock                   Lock wallet
+  caypo safeguards unlock                 Unlock wallet
+
+TRAFFIC
+  caypo traffic                           Validator traffic balance
+
+MCP
+  caypo mcp install                       Install for Claude/Cursor/Windsurf
+```
+
+## Examples
+
+### Set up a new wallet
+
+```
+$ caypo init
+
+  CAYPO — A bank account for AI agents on Canton Network
+
+  ? Choose a PIN for your wallet: ****
+  ? Confirm PIN: ****
+  ? Canton Ledger URL: http://localhost:7575
+  ? JWT bearer token: ****
+  ? Agent display name: MyAgent
+
+  [OK] Party allocated
+  [OK] Keystore created
+
+  Party ID: MyAgent::1220abcdef...
+  Config:   ~/.caypo/config.json
+```
+
+### Check balance
+
+```
+$ caypo balance
+
+  Checking Account
+
+  Balance:   50.00 USDCx
+  Holdings:  3 UTXOs
+  Address:   MyAgent::1220abcdef...
+  Network:   testnet
+```
+
+### Pay for an API call
+
+```
+$ caypo pay https://mpp.cayvox.io/openai/v1/chat/completions --max-price 0.05
+
+  [OK] Paid 0.01 USDCx for API access
+  Update ID: upd-abc123
+  Status:    200
+```
+
+### Install MCP server
+
+```
+$ caypo mcp install
+
+  [OK] Claude Desktop
+  [OK] Cursor
+  [OK] Windsurf
+
+  MCP server installed for 3 tools.
+  Restart your AI tool to activate.
+```
+
+## License
+
+Apache-2.0 OR MIT

package/SPEC.md

@@ -0,0 +1,41 @@
+# @cayvox/canton-cli — CLI Specification (Production)
+
+Binary: `canton-agent` (alias: `ca`)
+
+## Commands
+
+```
+SETUP
+  init                              Interactive: PIN, ledger URL, JWT, party allocation, MCP
+  address                           Party ID (e.g., Agent::1220abcd...)
+  balance                           All account balances
+  config                            Show/edit configuration
+  mcp install                       Install MCP server for Claude/Cursor/Windsurf
+  export-key                        Export private key (requires PIN)
+
+CHECKING
+  send <amount> to <recipient>      Send USDCx (party ID or ANS name)
+  history [--limit N]               Transaction history
+
+MPP PAYMENTS
+  pay <url> [--data json] [--method POST] [--max-price amount]
+
+SAFEGUARDS
+  safeguards                        Show settings
+  safeguards set-tx-limit <amount>
+  safeguards set-daily-limit <amount>
+  safeguards lock / unlock
+
+TRAFFIC
+  traffic                           Validator traffic balance
+  traffic purchase <cc-amount>      Buy traffic with CC
+
+PHASE 3+ (stubs in v1)
+  save, withdraw, rebalance, earnings
+  borrow, repay, health
+  exchange, rates
+  invest buy/sell/earn/strategy/auto/portfolio
+  claim-rewards
+```
+
+## Technology: commander + chalk + ora + inquirer

package/dist/index.js

@@ -0,0 +1,468 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import inquirer from "inquirer";
+import ora from "ora";
+import chalk2 from "chalk";
+import {
+  CantonClient,
+  Keystore,
+  saveConfig,
+  DEFAULT_CONFIG,
+  SafeguardManager
+} from "@caypo/canton-sdk";
+
+// src/helpers/format.ts
+import chalk from "chalk";
+var label = (text) => chalk.gray(text);
+var value = (text) => chalk.white.bold(text);
+var success = (text) => chalk.green(text);
+var warn = (text) => chalk.yellow(text);
+var fail = (text) => chalk.red(text);
+var accent = (text) => chalk.cyan(text);
+var dim = (text) => chalk.dim(text);
+function banner() {
+  console.log(chalk.cyan.bold("\n  CAYPO") + chalk.gray(" \u2014 A bank account for AI agents on Canton Network\n"));
+}
+function keyValue(key, val) {
+  console.log(`  ${label(key + ":")} ${value(val)}`);
+}
+function errorMessage(msg) {
+  console.log(`
+  ${fail("\u2717")} ${msg}
+`);
+}
+function successMessage(msg) {
+  console.log(`
+  ${success("\u2713")} ${msg}
+`);
+}
+
+// src/commands/init.ts
+var initCommand = new Command("init").description("Interactive wallet setup \u2014 create keystore, allocate party").action(async () => {
+  banner();
+  console.log(chalk2.gray("  Setting up your Canton agent wallet...\n"));
+  try {
+    const { pin } = await inquirer.prompt([
+      {
+        type: "password",
+        name: "pin",
+        message: "Choose a PIN for your wallet:",
+        mask: "*",
+        validate: (v) => v.length >= 4 || "PIN must be at least 4 characters"
+      }
+    ]);
+    const { confirmPin } = await inquirer.prompt([
+      {
+        type: "password",
+        name: "confirmPin",
+        message: "Confirm PIN:",
+        mask: "*",
+        validate: (v) => v === pin || "PINs do not match"
+      }
+    ]);
+    const { ledgerUrl } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "ledgerUrl",
+        message: "Canton Ledger URL:",
+        default: "http://localhost:7575"
+      }
+    ]);
+    const { jwt } = await inquirer.prompt([
+      {
+        type: "password",
+        name: "jwt",
+        message: "JWT bearer token:",
+        mask: "*",
+        validate: (v) => v.length > 0 || "JWT is required"
+      }
+    ]);
+    const { userId } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "userId",
+        message: "Ledger API user ID:",
+        default: "ledger-api-user"
+      }
+    ]);
+    const { displayName } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "displayName",
+        message: "Agent display name:",
+        default: "Agent"
+      }
+    ]);
+    const spinner = ora("Allocating party on Canton ledger...").start();
+    const client = new CantonClient({ ledgerUrl, token: jwt, userId });
+    let partyId;
+    try {
+      const party = await client.allocateParty(displayName);
+      partyId = party.party;
+      spinner.succeed("Party allocated");
+    } catch (err) {
+      spinner.fail("Failed to allocate party");
+      errorMessage(err.message);
+      process.exit(1);
+    }
+    const keystoreSpinner = ora("Creating encrypted keystore...").start();
+    await Keystore.create(pin, { partyId, jwt, userId });
+    keystoreSpinner.succeed("Keystore created");
+    const config = {
+      ...DEFAULT_CONFIG,
+      ledgerUrl,
+      partyId,
+      userId
+    };
+    await saveConfig(config);
+    const safeguards = new SafeguardManager();
+    safeguards.setTxLimit(DEFAULT_CONFIG.safeguards.txLimit);
+    safeguards.setDailyLimit(DEFAULT_CONFIG.safeguards.dailyLimit);
+    console.log("");
+    successMessage("Canton agent wallet created successfully!");
+    console.log("");
+    keyValue("Party ID", accent(partyId));
+    keyValue("Ledger URL", ledgerUrl);
+    keyValue("Config", "~/.caypo/config.json");
+    keyValue("Keystore", "~/.caypo/wallet.key");
+    console.log("");
+    console.log(chalk2.gray("  Next steps:"));
+    console.log(chalk2.gray("    caypo balance        \u2014 Check your balance"));
+    console.log(chalk2.gray("    caypo mcp install    \u2014 Install MCP server for AI tools"));
+    console.log(chalk2.gray("    caypo send 1 to <party>  \u2014 Send USDCx"));
+    console.log("");
+  } catch (err) {
+    errorMessage(`Setup failed: ${err.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/balance.ts
+import { Command as Command2 } from "commander";
+import chalk3 from "chalk";
+import ora2 from "ora";
+
+// src/helpers/load-agent.ts
+import { CantonAgent, loadConfig } from "@caypo/canton-sdk";
+async function loadAgent() {
+  try {
+    const config = await loadConfig();
+    if (!config.partyId) {
+      errorMessage("No wallet configured. Run 'caypo init' first.");
+      process.exit(1);
+    }
+    return CantonAgent.create({
+      ledgerUrl: config.ledgerUrl,
+      partyId: config.partyId,
+      userId: config.userId,
+      network: config.network,
+      token: process.env.CANTON_JWT ?? ""
+    });
+  } catch (err) {
+    errorMessage(`Failed to load agent: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/balance.ts
+var balanceCommand = new Command2("balance").description("Show USDCx checking balance").action(async () => {
+  banner();
+  const spinner = ora2("Fetching balance...").start();
+  try {
+    const agent = await loadAgent();
+    const bal = await agent.checking.balance();
+    spinner.stop();
+    console.log(chalk3.gray("  Checking Account\n"));
+    keyValue("Balance", accent(`${bal.available} USDCx`));
+    keyValue("Holdings", `${bal.holdingCount} UTXO${bal.holdingCount !== 1 ? "s" : ""}`);
+    keyValue("Address", agent.wallet.address);
+    keyValue("Network", agent.wallet.network);
+    console.log("");
+  } catch (err) {
+    spinner.fail(`Failed to fetch balance: ${err.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/send.ts
+import { Command as Command3 } from "commander";
+import ora3 from "ora";
+var sendCommand = new Command3("send").description("Send USDCx to a recipient").argument("<amount>", "Amount of USDCx to send").argument("to", "Literal 'to' keyword").argument("<recipient>", "Recipient party ID").option("--memo <memo>", "Optional memo").action(async (amount, _to, recipient, opts) => {
+  banner();
+  const spinner = ora3(`Sending ${amount} USDCx to ${recipient}...`).start();
+  try {
+    const agent = await loadAgent();
+    const result = await agent.checking.send(recipient, amount, { memo: opts.memo });
+    spinner.stop();
+    successMessage(`Sent ${accent(amount + " USDCx")} successfully!`);
+    keyValue("Recipient", recipient);
+    keyValue("Update ID", result.updateId);
+    keyValue("Offset", String(result.completionOffset));
+    keyValue("Command ID", result.commandId);
+    console.log("");
+  } catch (err) {
+    spinner.fail("Transfer failed");
+    errorMessage(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/pay.ts
+import { Command as Command4 } from "commander";
+import ora4 from "ora";
+var payCommand = new Command4("pay").description("Pay for an API call via MPP (402 auto-pay)").argument("<url>", "URL to fetch").option("-d, --data <json>", "Request body (JSON)").option("-X, --method <method>", "HTTP method", "GET").option("--max-price <amount>", "Maximum price to pay").action(async (url, opts) => {
+  banner();
+  const spinner = ora4(`Fetching ${url}...`).start();
+  try {
+    const agent = await loadAgent();
+    const result = await agent.mpp.pay(url, {
+      method: opts.method,
+      body: opts.data,
+      maxPrice: opts.maxPrice,
+      headers: opts.data ? { "Content-Type": "application/json" } : void 0
+    });
+    spinner.stop();
+    if (result.paid) {
+      successMessage(`Paid ${accent(result.receipt.amount + " USDCx")} for API access`);
+      keyValue("Update ID", result.receipt.updateId);
+      keyValue("Command ID", result.receipt.commandId);
+    } else {
+      console.log(dim("  No payment required (non-402 response)"));
+    }
+    keyValue("Status", String(result.response.status));
+    const body = await result.response.text();
+    if (body) {
+      console.log(dim("\n  Response:"));
+      console.log(dim("  " + body.slice(0, 500)));
+      if (body.length > 500) console.log(dim("  ... (truncated)"));
+    }
+    console.log("");
+  } catch (err) {
+    spinner.fail("Payment failed");
+    errorMessage(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/address.ts
+import { Command as Command5 } from "commander";
+var addressCommand = new Command5("address").description("Show your Canton party ID (address)").action(async () => {
+  banner();
+  try {
+    const agent = await loadAgent();
+    keyValue("Party ID", agent.wallet.address);
+    keyValue("Network", agent.wallet.network);
+    console.log("");
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/safeguards.ts
+import { Command as Command6 } from "commander";
+import inquirer2 from "inquirer";
+import chalk4 from "chalk";
+import { SafeguardManager as SafeguardManager2 } from "@caypo/canton-sdk";
+var safeguardsCommand = new Command6("safeguards").description("View and manage safeguard settings").action(async () => {
+  banner();
+  try {
+    const mgr = await SafeguardManager2.load();
+    const s = mgr.settings();
+    console.log(chalk4.gray("  Safeguard Settings\n"));
+    keyValue("Per-tx limit", accent(s.txLimit + " USDCx"));
+    keyValue("Daily limit", accent(s.dailyLimit + " USDCx"));
+    keyValue("Daily spent", s.dailySpent + " USDCx");
+    keyValue("Locked", s.locked ? warn("YES") : "no");
+    keyValue("Last reset", s.lastResetDate);
+    console.log("");
+  } catch (err) {
+    errorMessage(err.message);
+    process.exit(1);
+  }
+});
+safeguardsCommand.command("set-tx-limit").argument("<amount>", "Per-transaction limit in USDCx").description("Set per-transaction spending limit").action(async (amount) => {
+  try {
+    const mgr = await SafeguardManager2.load();
+    mgr.setTxLimit(amount);
+    successMessage(`Per-transaction limit set to ${accent(amount + " USDCx")}`);
+  } catch (err) {
+    errorMessage(err.message);
+    process.exit(1);
+  }
+});
+safeguardsCommand.command("set-daily-limit").argument("<amount>", "Daily spending limit in USDCx").description("Set daily spending limit").action(async (amount) => {
+  try {
+    const mgr = await SafeguardManager2.load();
+    mgr.setDailyLimit(amount);
+    successMessage(`Daily limit set to ${accent(amount + " USDCx")}`);
+  } catch (err) {
+    errorMessage(err.message);
+    process.exit(1);
+  }
+});
+safeguardsCommand.command("lock").description("Lock wallet \u2014 all transactions will be rejected").action(async () => {
+  try {
+    const { pin } = await inquirer2.prompt([
+      {
+        type: "password",
+        name: "pin",
+        message: "Set lock PIN:",
+        mask: "*"
+      }
+    ]);
+    const mgr = await SafeguardManager2.load();
+    mgr.lock(pin);
+    successMessage("Wallet locked");
+  } catch (err) {
+    errorMessage(err.message);
+    process.exit(1);
+  }
+});
+safeguardsCommand.command("unlock").description("Unlock wallet").action(async () => {
+  try {
+    const { pin } = await inquirer2.prompt([
+      {
+        type: "password",
+        name: "pin",
+        message: "Enter lock PIN:",
+        mask: "*"
+      }
+    ]);
+    const mgr = await SafeguardManager2.load();
+    mgr.unlock(pin);
+    successMessage("Wallet unlocked");
+  } catch (err) {
+    errorMessage(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/traffic.ts
+import { Command as Command7 } from "commander";
+import ora5 from "ora";
+import chalk5 from "chalk";
+var trafficCommand = new Command7("traffic").description("Show validator traffic balance").action(async () => {
+  banner();
+  const spinner = ora5("Checking traffic balance...").start();
+  try {
+    const agent = await loadAgent();
+    const balance = await agent.traffic.trafficBalance();
+    const sufficient = balance.remaining > 1e3;
+    spinner.stop();
+    console.log(chalk5.gray("  Validator Traffic\n"));
+    keyValue("Total purchased", accent(String(balance.totalPurchased)));
+    keyValue("Consumed", String(balance.consumed));
+    keyValue("Remaining", sufficient ? accent(String(balance.remaining)) : warn(String(balance.remaining)));
+    keyValue("Status", sufficient ? "Sufficient" : warn("Low \u2014 consider purchasing more"));
+    console.log("");
+  } catch (err) {
+    spinner.fail(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+});
+trafficCommand.command("purchase").argument("<cc-amount>", "Canton Coin amount to burn for traffic").description("Purchase additional traffic by burning CC").action(async (ccAmount) => {
+  const spinner = ora5(`Purchasing traffic with ${ccAmount} CC...`).start();
+  try {
+    const agent = await loadAgent();
+    await agent.traffic.purchaseTraffic(ccAmount);
+    spinner.succeed("Traffic purchased");
+  } catch (err) {
+    spinner.fail(`Purchase failed: ${err.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/mcp.ts
+import { Command as Command8 } from "commander";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { homedir, platform } from "os";
+import chalk6 from "chalk";
+var MCP_ENTRY = {
+  command: "npx",
+  args: ["@caypo/canton-mcp"],
+  env: { CANTON_AGENT_CONFIG: join(homedir(), ".caypo", "config.json") }
+};
+function getConfigPaths() {
+  const home = homedir();
+  const os = platform();
+  const paths = [];
+  if (os === "darwin") {
+    paths.push(
+      { name: "Claude Desktop", path: join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json") },
+      { name: "Cursor", path: join(home, ".cursor", "mcp.json") },
+      { name: "Windsurf", path: join(home, ".windsurf", "mcp.json") }
+    );
+  } else if (os === "linux") {
+    paths.push(
+      { name: "Claude Desktop", path: join(home, ".config", "Claude", "claude_desktop_config.json") },
+      { name: "Cursor", path: join(home, ".cursor", "mcp.json") },
+      { name: "Windsurf", path: join(home, ".windsurf", "mcp.json") }
+    );
+  } else {
+    const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
+    paths.push(
+      { name: "Claude Desktop", path: join(appData, "Claude", "claude_desktop_config.json") },
+      { name: "Cursor", path: join(home, ".cursor", "mcp.json") },
+      { name: "Windsurf", path: join(home, ".windsurf", "mcp.json") }
+    );
+  }
+  return paths;
+}
+async function installToConfig(configPath) {
+  let config;
+  try {
+    const raw = await readFile(configPath, "utf8");
+    config = JSON.parse(raw);
+  } catch {
+    config = { mcpServers: {} };
+  }
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  config.mcpServers["caypo"] = MCP_ENTRY;
+  await mkdir(join(configPath, ".."), { recursive: true });
+  await writeFile(configPath, JSON.stringify(config, null, 2), "utf8");
+  return true;
+}
+var mcpCommand = new Command8("mcp").description("MCP server management");
+mcpCommand.command("install").description("Install MCP server config for Claude Desktop, Cursor, Windsurf").action(async () => {
+  console.log(chalk6.gray("\n  Installing CAYPO MCP server configuration...\n"));
+  const configs = getConfigPaths();
+  let installed = 0;
+  for (const { name, path } of configs) {
+    try {
+      await installToConfig(path);
+      console.log(`  ${chalk6.green("\u2713")} ${name} ${dim(path)}`);
+      installed++;
+    } catch (err) {
+      console.log(`  ${chalk6.yellow("\u26A0")} ${name} \u2014 ${dim(err.message)}`);
+    }
+  }
+  if (installed > 0) {
+    successMessage(`MCP server installed for ${installed} tool${installed > 1 ? "s" : ""}`);
+    console.log(chalk6.gray("  Restart your AI tool to activate the MCP server."));
+    console.log(chalk6.gray("  The server provides 33 tools and 20 prompts for Canton banking.\n"));
+  } else {
+    errorMessage("No AI tool configs found. Install manually.");
+    console.log(chalk6.gray("  Add this to your MCP config:\n"));
+    console.log(chalk6.gray("  " + JSON.stringify({ caypo: MCP_ENTRY }, null, 2).replace(/\n/g, "\n  ")));
+    console.log("");
+  }
+});
+
+// src/index.ts
+var CANTON_CLI_VERSION = "0.1.0";
+var program = new Command9();
+program.name("caypo").description("CAYPO \u2014 A bank account for AI agents on Canton Network").version(CANTON_CLI_VERSION, "-v, --version").addCommand(initCommand).addCommand(balanceCommand).addCommand(sendCommand).addCommand(payCommand).addCommand(addressCommand).addCommand(safeguardsCommand).addCommand(trafficCommand).addCommand(mcpCommand);
+program.parse(process.argv);
+export {
+  CANTON_CLI_VERSION
+};
+//# sourceMappingURL=index.js.map