@agentwallet/cli 0.0.1

package/dist/cli.js

@@ -0,0 +1,982 @@
+#!/usr/bin/env bun
+// @bun
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../sdk/dist/index.js
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import { join, dirname } from "node:path";
+var CHAIN_MAP = {
+  ethereum: {
+    name: "ethereum",
+    chainId: 1,
+    type: "evm",
+    isTestnet: false,
+    displayName: "Ethereum",
+    explorer: "https://etherscan.io",
+    nativeToken: "ETH",
+    supportedTokens: ["eth", "usdc"]
+  },
+  base: {
+    name: "base",
+    chainId: 8453,
+    type: "evm",
+    isTestnet: false,
+    displayName: "Base",
+    explorer: "https://basescan.org",
+    nativeToken: "ETH",
+    supportedTokens: ["eth", "usdc"]
+  },
+  solana: {
+    name: "solana",
+    chainId: null,
+    type: "solana",
+    isTestnet: false,
+    displayName: "Solana",
+    explorer: "https://solscan.io",
+    nativeToken: "SOL",
+    supportedTokens: ["sol", "usdc"]
+  },
+  sepolia: {
+    name: "sepolia",
+    chainId: 11155111,
+    type: "evm",
+    isTestnet: true,
+    displayName: "Sepolia",
+    explorer: "https://sepolia.etherscan.io",
+    nativeToken: "ETH",
+    supportedTokens: ["eth", "usdc"]
+  },
+  "base-sepolia": {
+    name: "base-sepolia",
+    chainId: 84532,
+    type: "evm",
+    isTestnet: true,
+    displayName: "Base Sepolia",
+    explorer: "https://sepolia.basescan.org",
+    nativeToken: "ETH",
+    supportedTokens: ["eth", "usdc"]
+  },
+  "solana-devnet": {
+    name: "solana-devnet",
+    chainId: null,
+    type: "solana",
+    isTestnet: true,
+    displayName: "Solana Devnet",
+    explorer: "https://solscan.io/?cluster=devnet",
+    nativeToken: "SOL",
+    supportedTokens: ["sol", "usdc"]
+  },
+  tempo: {
+    name: "tempo",
+    chainId: null,
+    type: "evm",
+    isTestnet: true,
+    displayName: "Tempo Testnet",
+    explorer: "",
+    nativeToken: "ETH",
+    supportedTokens: ["eth"]
+  }
+};
+function resolveChain(chain) {
+  const config = CHAIN_MAP[chain];
+  if (!config) {
+    throw new Error(`Unknown chain: ${chain}`);
+  }
+  return config;
+}
+function getSolanaNetwork(chain) {
+  if (chain === "solana")
+    return "mainnet";
+  if (chain === "solana-devnet")
+    return "devnet";
+  throw new Error(`${chain} is not a Solana chain`);
+}
+function isChainName(value) {
+  return value in CHAIN_MAP;
+}
+
+class AgentWalletError extends Error {
+  code;
+  hint;
+  status;
+  constructor(message, options) {
+    super(message);
+    this.name = "AgentWalletError";
+    this.code = options?.code ?? "AGENT_WALLET_ERROR";
+    this.hint = options?.hint;
+    this.status = options?.status ?? 0;
+  }
+}
+
+class NotAuthenticatedError extends AgentWalletError {
+  constructor(message = "Not authenticated. Run `agentwallet connect` or call AgentWallet.connect().") {
+    super(message, { code: "NOT_AUTHENTICATED", status: 401 });
+    this.name = "NotAuthenticatedError";
+  }
+}
+
+class UnauthorizedError extends AgentWalletError {
+  constructor(message = "Unauthorized", hint) {
+    super(message, { code: "UNAUTHORIZED", hint, status: 401 });
+    this.name = "UnauthorizedError";
+  }
+}
+
+class InsufficientFundsError extends AgentWalletError {
+  constructor(message = "Insufficient funds", hint) {
+    super(message, { code: "INSUFFICIENT_FUNDS", hint, status: 400 });
+    this.name = "InsufficientFundsError";
+  }
+}
+
+class InvalidAddressError extends AgentWalletError {
+  constructor(message = "Invalid address", hint) {
+    super(message, { code: "INVALID_ADDRESS", hint, status: 400 });
+    this.name = "InvalidAddressError";
+  }
+}
+class SpendingLimitError extends AgentWalletError {
+  constructor(message = "Spending limit exceeded", hint) {
+    super(message, { code: "SPENDING_LIMIT", hint, status: 403 });
+    this.name = "SpendingLimitError";
+  }
+}
+
+class AllowlistError extends AgentWalletError {
+  constructor(message = "Address or chain not in allowlist", hint) {
+    super(message, { code: "ALLOWLIST", hint, status: 403 });
+    this.name = "AllowlistError";
+  }
+}
+
+class NetworkError extends AgentWalletError {
+  constructor(message = "Network request failed", hint) {
+    super(message, { code: "NETWORK_ERROR", hint, status: 0 });
+    this.name = "NetworkError";
+  }
+}
+function errorFromResponse(status, body) {
+  const msg = body.error ?? `Request failed with status ${status}`;
+  const hint = body.hint;
+  if (status === 401) {
+    return new UnauthorizedError(msg, hint);
+  }
+  const lower = msg.toLowerCase();
+  if (lower.includes("insufficient") || lower.includes("not enough")) {
+    return new InsufficientFundsError(msg, hint);
+  }
+  if (lower.includes("invalid address") || lower.includes("bad address")) {
+    return new InvalidAddressError(msg, hint);
+  }
+  if (lower.includes("spending limit") || lower.includes("limit exceeded")) {
+    return new SpendingLimitError(msg, hint);
+  }
+  if (lower.includes("allowlist") || lower.includes("not allowed")) {
+    return new AllowlistError(msg, hint);
+  }
+  return new AgentWalletError(msg, { hint, status, code: "API_ERROR" });
+}
+function getDefaultConfigDir() {
+  const home = homedir();
+  switch (platform()) {
+    case "darwin":
+      return join(home, "Library", "Application Support", "agentwallet");
+    case "win32":
+      return join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), "agentwallet");
+    default:
+      return join(home, ".config", "agentwallet");
+  }
+}
+var LEGACY_CONFIG_PATH = join(homedir(), ".agentwallet", "config.json");
+
+class FileCredentialStorage {
+  configPath;
+  constructor(configDir) {
+    const dir = configDir ?? getDefaultConfigDir();
+    this.configPath = join(dir, "credentials.json");
+  }
+  getPath() {
+    return this.configPath;
+  }
+  async get() {
+    const creds = await this.readFile(this.configPath);
+    if (creds)
+      return creds;
+    const legacy = await this.readLegacy();
+    if (legacy) {
+      await this.set(legacy);
+      return legacy;
+    }
+    return null;
+  }
+  async set(credentials) {
+    const dir = dirname(this.configPath);
+    await mkdir(dir, { recursive: true });
+    await writeFile(this.configPath, JSON.stringify(credentials, null, 2) + `
+`, { mode: 384 });
+  }
+  async delete() {
+    try {
+      const { unlink } = await import("node:fs/promises");
+      await unlink(this.configPath);
+    } catch {}
+  }
+  async readFile(path) {
+    try {
+      const raw = await readFile(path, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.username && data.apiToken) {
+        return {
+          username: data.username,
+          email: data.email ?? "",
+          evmAddress: data.evmAddress ?? "",
+          solanaAddress: data.solanaAddress ?? "",
+          apiToken: data.apiToken
+        };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async readLegacy() {
+    try {
+      const raw = await readFile(LEGACY_CONFIG_PATH, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.username && data.apiToken) {
+        return {
+          username: data.username,
+          email: data.email ?? "",
+          evmAddress: data.evmAddress ?? "",
+          solanaAddress: data.solanaAddress ?? "",
+          apiToken: data.apiToken
+        };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+}
+var TOOL_DEFINITIONS = [
+  {
+    name: "get_balances",
+    description: "Get all token balances across chains for this wallet.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "get_addresses",
+    description: "Get the wallet addresses (EVM and Solana).",
+    input_schema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "transfer",
+    description: "Transfer tokens to an address on a specific chain.",
+    input_schema: {
+      type: "object",
+      properties: {
+        chain: {
+          type: "string",
+          description: "Chain name: ethereum, base, solana, sepolia, base-sepolia, solana-devnet",
+          enum: ["ethereum", "base", "solana", "sepolia", "base-sepolia", "solana-devnet"]
+        },
+        to: {
+          type: "string",
+          description: "Recipient address"
+        },
+        amount: {
+          type: "string",
+          description: "Amount to send (in smallest unit, e.g. wei or lamports)"
+        },
+        currency: {
+          type: "string",
+          description: "Token to send (e.g. eth, usdc, sol). Defaults to chain native token."
+        }
+      },
+      required: ["chain", "to", "amount"]
+    }
+  },
+  {
+    name: "get_transaction_history",
+    description: "Get recent transaction history.",
+    input_schema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Maximum number of transactions to return (default 20)"
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "x402_fetch",
+    description: "Make an HTTP request with automatic x402 payment handling.",
+    input_schema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "URL to fetch"
+        },
+        method: {
+          type: "string",
+          enum: ["GET", "POST", "PUT", "DELETE", "PATCH"],
+          description: "HTTP method (default GET)"
+        },
+        body: {
+          type: "object",
+          description: "Request body (for POST/PUT/PATCH)"
+        },
+        dryRun: {
+          type: "boolean",
+          description: "If true, only preview payment without executing"
+        }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "request_faucet",
+    description: "Request testnet tokens from the faucet (Solana devnet).",
+    input_schema: {
+      type: "object",
+      properties: {
+        chain: {
+          type: "string",
+          description: "Chain to request faucet on (default: solana-devnet)",
+          enum: ["solana-devnet"]
+        }
+      },
+      required: []
+    }
+  }
+];
+function createTools(wallet) {
+  async function execute(name, input) {
+    switch (name) {
+      case "get_balances":
+        return wallet.getBalances();
+      case "get_addresses":
+        return wallet.getAddresses();
+      case "transfer":
+        return wallet.transfer({
+          chain: input.chain,
+          to: input.to,
+          amount: input.amount,
+          currency: input.currency
+        });
+      case "get_transaction_history":
+        return wallet.getTransactionHistory({
+          limit: input.limit ?? 20
+        });
+      case "x402_fetch":
+        return wallet.x402Fetch({
+          url: input.url,
+          method: input.method,
+          body: input.body,
+          dryRun: input.dryRun
+        });
+      case "request_faucet":
+        return wallet.requestFaucet({
+          chain: input.chain ?? "solana-devnet"
+        });
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  }
+  return {
+    definitions: TOOL_DEFINITIONS,
+    execute
+  };
+}
+var DEFAULT_BASE_URL = "https://frames.ag/api";
+
+class AgentWallet {
+  baseUrl;
+  apiToken;
+  _username;
+  _addresses;
+  storage;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.apiToken = config.apiToken;
+    this._username = config.username;
+    this._addresses = config.addresses;
+    this.storage = config.storage;
+  }
+  static async connect(options = {}) {
+    const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    const storage = options.credentialStorage ?? new FileCredentialStorage;
+    const existing = await storage.get();
+    if (existing) {
+      return new AgentWallet({
+        baseUrl,
+        apiToken: existing.apiToken,
+        username: existing.username,
+        addresses: { evm: existing.evmAddress, solana: existing.solanaAddress },
+        storage
+      });
+    }
+    let email = options.email;
+    if (!email) {
+      if (!options.onEmailPrompt) {
+        throw new NotAuthenticatedError("No stored credentials and no email/onEmailPrompt provided.");
+      }
+      email = await options.onEmailPrompt();
+    }
+    const startRes = await fetch(`${baseUrl}/connect/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, ref: options.ref })
+    });
+    const startJson = await startRes.json();
+    const username = startJson.username;
+    if (!options.onOtpPrompt) {
+      throw new NotAuthenticatedError("OTP sent but no onOtpPrompt callback provided.");
+    }
+    const otp = await options.onOtpPrompt(email);
+    const completeRes = await fetch(`${baseUrl}/connect/complete`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ username, email, otp })
+    });
+    const completeJson = await completeRes.json();
+    const credentials = {
+      username,
+      email,
+      evmAddress: completeJson.evmAddress,
+      solanaAddress: completeJson.solanaAddress,
+      apiToken: completeJson.apiToken
+    };
+    await storage.set(credentials);
+    return new AgentWallet({
+      baseUrl,
+      apiToken: completeJson.apiToken,
+      username,
+      addresses: { evm: completeJson.evmAddress, solana: completeJson.solanaAddress },
+      storage
+    });
+  }
+  static async fromApiKey(apiToken, options = {}) {
+    const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    const storage = options.credentialStorage ?? new FileCredentialStorage;
+    if (options.username) {
+      const res = await fetch(`${baseUrl}/wallets/${options.username}`, {
+        headers: { Authorization: `Bearer ${apiToken}` }
+      });
+      const info = await res.json();
+      return new AgentWallet({
+        baseUrl,
+        apiToken,
+        username: options.username,
+        addresses: { evm: info.evmAddress ?? "", solana: info.solanaAddress ?? "" },
+        storage
+      });
+    }
+    const stored = await storage.get();
+    if (stored?.username) {
+      return new AgentWallet({
+        baseUrl,
+        apiToken,
+        username: stored.username,
+        addresses: { evm: stored.evmAddress, solana: stored.solanaAddress },
+        storage
+      });
+    }
+    throw new NotAuthenticatedError("Username required: provide `username` option or have stored credentials.");
+  }
+  static async fromEnv(options = {}) {
+    const apiToken = process.env.AGENTWALLET_API_TOKEN;
+    const username = process.env.AGENTWALLET_USERNAME;
+    const baseUrl = options.baseUrl ?? process.env.AGENTWALLET_BASE_URL ?? DEFAULT_BASE_URL;
+    if (apiToken) {
+      return AgentWallet.fromApiKey(apiToken, { baseUrl, username });
+    }
+    const storage = new FileCredentialStorage;
+    const stored = await storage.get();
+    if (stored) {
+      return new AgentWallet({
+        baseUrl: baseUrl.replace(/\/$/, ""),
+        apiToken: stored.apiToken,
+        username: stored.username,
+        addresses: { evm: stored.evmAddress, solana: stored.solanaAddress },
+        storage
+      });
+    }
+    throw new NotAuthenticatedError;
+  }
+  get agentId() {
+    return this._username;
+  }
+  get username() {
+    return this._username;
+  }
+  isAuthenticated() {
+    return !!this.apiToken && !!this._username;
+  }
+  async disconnect() {
+    await this.storage.delete();
+  }
+  getAddresses() {
+    return { ...this._addresses };
+  }
+  getAddress(chain) {
+    const config = resolveChain(chain);
+    if (config.type === "solana")
+      return this._addresses.solana;
+    return this._addresses.evm;
+  }
+  async getBalances() {
+    return this.request("GET", `/wallets/${this._username}/balances`, { auth: true });
+  }
+  async getBalance(chain) {
+    const balances = await this.getBalances();
+    const chainConfig = resolveChain(chain);
+    const match = balances.find((b) => b.chain.toLowerCase() === chainConfig.displayName.toLowerCase());
+    if (!match) {
+      return { chain: chainConfig.displayName, token: chainConfig.nativeToken, amount: "0", formatted: "0" };
+    }
+    return match;
+  }
+  async transfer(req) {
+    const chainConfig = resolveChain(req.chain);
+    if (chainConfig.type === "solana") {
+      const network = getSolanaNetwork(req.chain);
+      const asset2 = req.currency ?? "sol";
+      const result2 = await this.request("POST", `/wallets/${this._username}/actions/transfer-solana`, {
+        body: { to: req.to, amount: req.amount, asset: asset2, network, idempotencyKey: req.idempotencyKey },
+        auth: true
+      });
+      return actionToTransaction(result2, req.chain);
+    }
+    const asset = req.currency ?? "usdc";
+    const chainId = chainConfig.chainId;
+    const result = await this.request("POST", `/wallets/${this._username}/actions/transfer`, {
+      body: { to: req.to, amount: req.amount, asset, chainId, idempotencyKey: req.idempotencyKey },
+      auth: true
+    });
+    return actionToTransaction(result, req.chain);
+  }
+  async getTransactionHistory(options = {}) {
+    const limit = options.limit ?? 50;
+    const events = await this.request("GET", `/wallets/${this._username}/activity?limit=${limit}`, { auth: true });
+    return events.map((e) => ({
+      id: e.id,
+      status: e.status ?? e.type,
+      hash: e.txHash,
+      chain: e.chain,
+      to: e.to,
+      amount: e.amount,
+      currency: e.token,
+      timestamp: e.timestamp
+    }));
+  }
+  async requestFaucet(req = {}) {
+    const result = await this.request("POST", `/wallets/${this._username}/actions/faucet-sol`, {
+      body: {},
+      auth: true
+    });
+    return {
+      amount: result.amount,
+      remaining: result.remaining,
+      transaction: actionToTransaction(result, req.chain ?? "solana-devnet")
+    };
+  }
+  async x402Fetch(req) {
+    return this.request("POST", `/wallets/${this._username}/actions/x402/fetch`, { body: req, auth: true });
+  }
+  async x402Pay(req) {
+    return this.request("POST", `/wallets/${this._username}/actions/x402/pay`, {
+      body: req,
+      auth: true
+    });
+  }
+  async getPolicy() {
+    return this.request("GET", `/wallets/${this._username}/policy`, { auth: true });
+  }
+  async updatePolicy(req) {
+    return this.request("PATCH", `/wallets/${this._username}/policy`, { body: req, auth: true });
+  }
+  async getReferrals() {
+    return this.request("GET", `/wallets/${this._username}/referrals`, { auth: true });
+  }
+  async getStats() {
+    return this.request("GET", `/wallets/${this._username}/stats`, { auth: true });
+  }
+  static async getNetworkPulse(baseUrl) {
+    const url = (baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    const res = await fetch(`${url}/network/pulse`);
+    return await res.json();
+  }
+  tools() {
+    return createTools(this);
+  }
+  mcp() {
+    const t = createTools(this);
+    return {
+      name: "agentwallet",
+      version: "0.0.1",
+      tools: t.definitions
+    };
+  }
+  getAvailableChains() {
+    return Object.values(CHAIN_MAP);
+  }
+  async signMessage(req) {
+    return this.request("POST", `/wallets/${this._username}/actions/sign-message`, {
+      body: req,
+      auth: true
+    });
+  }
+  async contractCall(req) {
+    const result = await this.request("POST", `/wallets/${this._username}/actions/contract-call`, {
+      body: req,
+      auth: true
+    });
+    return actionToTransaction(result);
+  }
+  async request(method, path, options) {
+    const headers = {};
+    if (options?.auth) {
+      headers["Authorization"] = `Bearer ${this.apiToken}`;
+    }
+    if (options?.body !== undefined) {
+      headers["Content-Type"] = "application/json";
+    }
+    let res;
+    try {
+      res = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers,
+        body: options?.body !== undefined ? JSON.stringify(options.body) : undefined
+      });
+    } catch (err) {
+      throw new NetworkError(`Request failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let json;
+    try {
+      json = await res.json();
+    } catch {
+      throw new NetworkError(`Failed to parse response from ${path} (status ${res.status})`);
+    }
+    if (json.success === false) {
+      throw errorFromResponse(res.status, { error: json.error, hint: json.hint });
+    }
+    if (json.success === true && "data" in json) {
+      return json.data;
+    }
+    if (!res.ok) {
+      throw errorFromResponse(res.status, { error: json.error ?? json.message ?? String(json) });
+    }
+    return json.data ?? json;
+  }
+}
+function actionToTransaction(action, chain) {
+  return {
+    id: action.actionId,
+    hash: action.txHash,
+    status: action.status,
+    explorerUrl: action.explorer,
+    chain
+  };
+}
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+var subcommand = args[1];
+function usage() {
+  console.log(`agentwallet - AgentWallet CLI
+
+Usage:
+  agentwallet connect                           Connect wallet via email OTP
+  agentwallet status                            Show connection status and addresses
+  agentwallet addresses                         Show wallet addresses
+  agentwallet balances [--chain <name>]         Show wallet balances
+  agentwallet transfer --chain <name> --to <addr> --amount <n> [--currency <tok>]
+  agentwallet history [--limit N] [--chain <name>]  Show transaction history
+  agentwallet chains                            List available chains
+  agentwallet faucet [--chain solana-devnet]    Request testnet tokens
+  agentwallet sign <evm|solana> <message>       Sign a message
+  agentwallet x402 <url> [options]              Make x402 payment request
+  agentwallet policy                            Show current policy
+  agentwallet referrals                         Show referral info
+  agentwallet stats                             Show personal stats
+  agentwallet pulse                             Show network pulse
+  agentwallet disconnect                        Clear stored credentials
+  agentwallet config                            Show config file path
+  agentwallet help                              Show this help`);
+}
+function flag(name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx === -1 || idx + 1 >= args.length)
+    return;
+  return args[idx + 1];
+}
+function promptInput(prompt) {
+  process.stdout.write(prompt);
+  const buf = Buffer.alloc(1024);
+  const fd = __require("fs").openSync("/dev/tty", "r");
+  const n = __require("fs").readSync(fd, buf, 0, 1024, null);
+  __require("fs").closeSync(fd);
+  return Promise.resolve(buf.toString("utf-8", 0, n).trim());
+}
+async function getClient() {
+  try {
+    return await AgentWallet.fromEnv();
+  } catch {
+    console.error("Not connected. Run: agentwallet connect");
+    process.exit(1);
+  }
+}
+async function connect() {
+  const storage = new FileCredentialStorage;
+  const existing = await storage.get();
+  if (existing) {
+    console.log(`Already connected as ${existing.username}`);
+    console.log(`EVM:    ${existing.evmAddress}`);
+    console.log(`Solana: ${existing.solanaAddress}`);
+    return;
+  }
+  const ref = flag("ref");
+  const wallet = await AgentWallet.connect({
+    email: flag("email") ?? undefined,
+    onEmailPrompt: () => promptInput("Email: "),
+    onOtpPrompt: (email) => {
+      console.log(`OTP sent to ${email}`);
+      return promptInput("Enter OTP: ");
+    },
+    ref: ref ?? undefined,
+    credentialStorage: storage
+  });
+  const addrs = wallet.getAddresses();
+  console.log(`Connected as ${wallet.username}`);
+  console.log(`EVM:    ${addrs.evm}`);
+  console.log(`Solana: ${addrs.solana}`);
+  console.log(`Config saved to ${storage.getPath()}`);
+}
+function requireChainFlag() {
+  const chain = flag("chain");
+  if (!chain) {
+    console.error("Missing --chain flag. Use `agentwallet chains` to see available chains.");
+    process.exit(1);
+  }
+  if (!isChainName(chain)) {
+    console.error(`Unknown chain: ${chain}. Use \`agentwallet chains\` to see available chains.`);
+    process.exit(1);
+  }
+  return chain;
+}
+async function run() {
+  try {
+    switch (command) {
+      case "connect":
+        await connect();
+        break;
+      case "status": {
+        const storage = new FileCredentialStorage;
+        const creds = await storage.get();
+        if (!creds) {
+          console.log("Not connected");
+          break;
+        }
+        console.log(`Username:  ${creds.username}`);
+        console.log(`EVM:       ${creds.evmAddress}`);
+        console.log(`Solana:    ${creds.solanaAddress}`);
+        console.log(`Connected: true`);
+        break;
+      }
+      case "addresses": {
+        const client = await getClient();
+        const addrs = client.getAddresses();
+        console.log(`EVM:    ${addrs.evm}`);
+        console.log(`Solana: ${addrs.solana}`);
+        break;
+      }
+      case "balances": {
+        const client = await getClient();
+        const chainName = flag("chain");
+        if (chainName) {
+          if (!isChainName(chainName)) {
+            console.error(`Unknown chain: ${chainName}. Use \`agentwallet chains\` to see available chains.`);
+            process.exit(1);
+          }
+          const b = await client.getBalance(chainName);
+          console.log(`${b.formatted} ${b.token} (${b.chain})`);
+          break;
+        }
+        const balances = await client.getBalances();
+        if (!balances.length) {
+          console.log("No balances found");
+          break;
+        }
+        for (const b of balances) {
+          console.log(`${b.formatted} ${b.token} (${b.chain})`);
+        }
+        break;
+      }
+      case "transfer": {
+        const client = await getClient();
+        const chain = requireChainFlag();
+        const to = flag("to");
+        const amount = flag("amount");
+        const currency = flag("currency") ?? undefined;
+        if (!to || !amount) {
+          console.error("Usage: agentwallet transfer --chain <name> --to <addr> --amount <n> [--currency <tok>]");
+          process.exit(1);
+        }
+        const tx = await client.transfer({ chain, to, amount, currency });
+        console.log(`TX: ${tx.hash ?? tx.id}`);
+        if (tx.explorerUrl)
+          console.log(tx.explorerUrl);
+        break;
+      }
+      case "history": {
+        const client = await getClient();
+        const limit = flag("limit") ? parseInt(flag("limit"), 10) : 20;
+        const chainOpt = flag("chain");
+        const chainFilter = chainOpt && isChainName(chainOpt) ? chainOpt : undefined;
+        const txs = await client.getTransactionHistory({ limit, chain: chainFilter });
+        if (!txs.length) {
+          console.log("No transactions found");
+          break;
+        }
+        for (const tx of txs) {
+          const ts = tx.timestamp ? `[${tx.timestamp}]` : "";
+          const hash = tx.hash ? ` ${tx.hash.slice(0, 10)}...` : "";
+          console.log(`${ts} ${tx.status}${hash} ${tx.id}`);
+        }
+        break;
+      }
+      case "chains": {
+        const chains = Object.values(CHAIN_MAP);
+        for (const c of chains) {
+          const testnet = c.isTestnet ? " (testnet)" : "";
+          console.log(`  ${c.name.padEnd(16)} ${c.displayName}${testnet}  [${c.type}]  tokens: ${c.supportedTokens.join(", ")}`);
+        }
+        break;
+      }
+      case "faucet": {
+        const client = await getClient();
+        const chainName = flag("chain");
+        const chain = chainName && isChainName(chainName) ? chainName : undefined;
+        const result = await client.requestFaucet({ chain });
+        console.log(`${result.amount} sent. TX: ${result.transaction.hash ?? result.transaction.id}`);
+        console.log(`Remaining today: ${result.remaining}`);
+        break;
+      }
+      case "stats": {
+        const client = await getClient();
+        const stats = await client.getStats();
+        console.log(JSON.stringify(stats, null, 2));
+        break;
+      }
+      case "sign": {
+        const client = await getClient();
+        const chain = subcommand;
+        const message = args[2];
+        if (!chain || !message) {
+          console.error("Usage: agentwallet sign <evm|solana> <message>");
+          process.exit(1);
+        }
+        const result = await client.signMessage({ chain, message });
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+      case "x402": {
+        const client = await getClient();
+        const url = subcommand;
+        if (!url) {
+          console.error("Usage: agentwallet x402 <url> [--method POST] [--body '{...}'] [--chain auto] [--dry-run]");
+          process.exit(1);
+        }
+        const method = flag("method") ?? "GET";
+        const bodyRaw = flag("body");
+        const body = bodyRaw ? JSON.parse(bodyRaw) : undefined;
+        const preferredChain = flag("chain") ?? "auto";
+        const dryRun = args.includes("--dry-run");
+        const result = await client.x402Fetch({ url, method, body, preferredChain, dryRun });
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+      case "policy": {
+        const client = await getClient();
+        const policy = await client.getPolicy();
+        console.log(JSON.stringify(policy, null, 2));
+        break;
+      }
+      case "referrals": {
+        const client = await getClient();
+        const info = await client.getReferrals();
+        console.log(JSON.stringify(info, null, 2));
+        break;
+      }
+      case "pulse": {
+        const pulse = await AgentWallet.getNetworkPulse();
+        console.log(JSON.stringify(pulse, null, 2));
+        break;
+      }
+      case "disconnect": {
+        const storage = new FileCredentialStorage;
+        await storage.delete();
+        console.log("Credentials cleared.");
+        break;
+      }
+      case "config": {
+        const storage = new FileCredentialStorage;
+        console.log(storage.getPath());
+        break;
+      }
+      case "help":
+      case undefined:
+        usage();
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        usage();
+        process.exit(1);
+    }
+  } catch (err) {
+    if (err instanceof AgentWalletError) {
+      console.error(`Error: ${err.message}`);
+      if (err.hint) {
+        console.error(`Hint: ${err.hint}`);
+      }
+      if (err.code && err.code !== "API_ERROR" && err.code !== "AGENT_WALLET_ERROR") {
+        console.error(`Code: ${err.code}`);
+      }
+    } else if (err instanceof Error) {
+      console.error(`Error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+run();

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@agentwallet/cli",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": {
+    "agentwallet": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "bun build ./src/cli.ts --outdir ./dist --target node",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@agentwallet/sdk": "workspace:*"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "bun-types": "^1.2.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,305 @@
+#!/usr/bin/env bun
+import {
+  AgentWallet,
+  AgentWalletError,
+  FileCredentialStorage,
+  CHAIN_MAP,
+  isChainName,
+} from "@agentwallet/sdk";
+import type { ChainName } from "@agentwallet/sdk";
+
+const args = process.argv.slice(2);
+const command = args[0];
+const subcommand = args[1];
+
+function usage(): void {
+  console.log(`agentwallet - AgentWallet CLI
+
+Usage:
+  agentwallet connect                           Connect wallet via email OTP
+  agentwallet status                            Show connection status and addresses
+  agentwallet addresses                         Show wallet addresses
+  agentwallet balances [--chain <name>]         Show wallet balances
+  agentwallet transfer --chain <name> --to <addr> --amount <n> [--currency <tok>]
+  agentwallet history [--limit N] [--chain <name>]  Show transaction history
+  agentwallet chains                            List available chains
+  agentwallet faucet [--chain solana-devnet]    Request testnet tokens
+  agentwallet sign <evm|solana> <message>       Sign a message
+  agentwallet x402 <url> [options]              Make x402 payment request
+  agentwallet policy                            Show current policy
+  agentwallet referrals                         Show referral info
+  agentwallet stats                             Show personal stats
+  agentwallet pulse                             Show network pulse
+  agentwallet disconnect                        Clear stored credentials
+  agentwallet config                            Show config file path
+  agentwallet help                              Show this help`);
+}
+
+function flag(name: string): string | undefined {
+  const idx = args.indexOf(`--${name}`);
+  if (idx === -1 || idx + 1 >= args.length) return undefined;
+  return args[idx + 1];
+}
+
+function promptInput(prompt: string): Promise<string> {
+  process.stdout.write(prompt);
+  const buf = Buffer.alloc(1024);
+  const fd = require("node:fs").openSync("/dev/tty", "r");
+  const n = require("node:fs").readSync(fd, buf, 0, 1024, null);
+  require("node:fs").closeSync(fd);
+  return Promise.resolve(buf.toString("utf-8", 0, n).trim());
+}
+
+async function getClient(): Promise<AgentWallet> {
+  try {
+    return await AgentWallet.fromEnv();
+  } catch {
+    console.error("Not connected. Run: agentwallet connect");
+    process.exit(1);
+  }
+}
+
+async function connect(): Promise<void> {
+  const storage = new FileCredentialStorage();
+  const existing = await storage.get();
+  if (existing) {
+    console.log(`Already connected as ${existing.username}`);
+    console.log(`EVM:    ${existing.evmAddress}`);
+    console.log(`Solana: ${existing.solanaAddress}`);
+    return;
+  }
+
+  const ref = flag("ref");
+  const wallet = await AgentWallet.connect({
+    email: flag("email") ?? undefined,
+    onEmailPrompt: () => promptInput("Email: "),
+    onOtpPrompt: (email) => {
+      console.log(`OTP sent to ${email}`);
+      return promptInput("Enter OTP: ");
+    },
+    ref: ref ?? undefined,
+    credentialStorage: storage,
+  });
+
+  const addrs = wallet.getAddresses();
+  console.log(`Connected as ${wallet.username}`);
+  console.log(`EVM:    ${addrs.evm}`);
+  console.log(`Solana: ${addrs.solana}`);
+  console.log(`Config saved to ${storage.getPath()}`);
+}
+
+function requireChainFlag(): ChainName {
+  const chain = flag("chain");
+  if (!chain) {
+    console.error("Missing --chain flag. Use `agentwallet chains` to see available chains.");
+    process.exit(1);
+  }
+  if (!isChainName(chain)) {
+    console.error(`Unknown chain: ${chain}. Use \`agentwallet chains\` to see available chains.`);
+    process.exit(1);
+  }
+  return chain;
+}
+
+async function run(): Promise<void> {
+  try {
+    switch (command) {
+      case "connect":
+        await connect();
+        break;
+
+      case "status": {
+        const storage = new FileCredentialStorage();
+        const creds = await storage.get();
+        if (!creds) {
+          console.log("Not connected");
+          break;
+        }
+        console.log(`Username:  ${creds.username}`);
+        console.log(`EVM:       ${creds.evmAddress}`);
+        console.log(`Solana:    ${creds.solanaAddress}`);
+        console.log(`Connected: true`);
+        break;
+      }
+
+      case "addresses": {
+        const client = await getClient();
+        const addrs = client.getAddresses();
+        console.log(`EVM:    ${addrs.evm}`);
+        console.log(`Solana: ${addrs.solana}`);
+        break;
+      }
+
+      case "balances": {
+        const client = await getClient();
+        const chainName = flag("chain");
+        if (chainName) {
+          if (!isChainName(chainName)) {
+            console.error(`Unknown chain: ${chainName}. Use \`agentwallet chains\` to see available chains.`);
+            process.exit(1);
+          }
+          const b = await client.getBalance(chainName);
+          console.log(`${b.formatted} ${b.token} (${b.chain})`);
+          break;
+        }
+        const balances = await client.getBalances();
+        if (!balances.length) {
+          console.log("No balances found");
+          break;
+        }
+        for (const b of balances) {
+          console.log(`${b.formatted} ${b.token} (${b.chain})`);
+        }
+        break;
+      }
+
+      case "transfer": {
+        const client = await getClient();
+        const chain = requireChainFlag();
+        const to = flag("to");
+        const amount = flag("amount");
+        const currency = flag("currency") ?? undefined;
+        if (!to || !amount) {
+          console.error("Usage: agentwallet transfer --chain <name> --to <addr> --amount <n> [--currency <tok>]");
+          process.exit(1);
+        }
+        const tx = await client.transfer({ chain, to, amount, currency });
+        console.log(`TX: ${tx.hash ?? tx.id}`);
+        if (tx.explorerUrl) console.log(tx.explorerUrl);
+        break;
+      }
+
+      case "history": {
+        const client = await getClient();
+        const limit = flag("limit") ? parseInt(flag("limit")!, 10) : 20;
+        const chainOpt = flag("chain");
+        const chainFilter = chainOpt && isChainName(chainOpt) ? chainOpt : undefined;
+        const txs = await client.getTransactionHistory({ limit, chain: chainFilter });
+        if (!txs.length) {
+          console.log("No transactions found");
+          break;
+        }
+        for (const tx of txs) {
+          const ts = tx.timestamp ? `[${tx.timestamp}]` : "";
+          const hash = tx.hash ? ` ${tx.hash.slice(0, 10)}...` : "";
+          console.log(`${ts} ${tx.status}${hash} ${tx.id}`);
+        }
+        break;
+      }
+
+      case "chains": {
+        const chains = Object.values(CHAIN_MAP);
+        for (const c of chains) {
+          const testnet = c.isTestnet ? " (testnet)" : "";
+          console.log(`  ${c.name.padEnd(16)} ${c.displayName}${testnet}  [${c.type}]  tokens: ${c.supportedTokens.join(", ")}`);
+        }
+        break;
+      }
+
+      case "faucet": {
+        const client = await getClient();
+        const chainName = flag("chain");
+        const chain = chainName && isChainName(chainName) ? chainName : undefined;
+        const result = await client.requestFaucet({ chain });
+        console.log(`${result.amount} sent. TX: ${result.transaction.hash ?? result.transaction.id}`);
+        console.log(`Remaining today: ${result.remaining}`);
+        break;
+      }
+
+      case "stats": {
+        const client = await getClient();
+        const stats = await client.getStats();
+        console.log(JSON.stringify(stats, null, 2));
+        break;
+      }
+
+      case "sign": {
+        const client = await getClient();
+        const chain = subcommand as "evm" | "solana";
+        const message = args[2];
+        if (!chain || !message) {
+          console.error("Usage: agentwallet sign <evm|solana> <message>");
+          process.exit(1);
+        }
+        const result = await client.signMessage({ chain, message });
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+
+      case "x402": {
+        const client = await getClient();
+        const url = subcommand;
+        if (!url) {
+          console.error("Usage: agentwallet x402 <url> [--method POST] [--body '{...}'] [--chain auto] [--dry-run]");
+          process.exit(1);
+        }
+        const method = (flag("method") ?? "GET") as "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+        const bodyRaw = flag("body");
+        const body = bodyRaw ? JSON.parse(bodyRaw) : undefined;
+        const preferredChain = (flag("chain") ?? "auto") as "auto" | "evm" | "solana";
+        const dryRun = args.includes("--dry-run");
+        const result = await client.x402Fetch({ url, method, body, preferredChain, dryRun });
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+
+      case "policy": {
+        const client = await getClient();
+        const policy = await client.getPolicy();
+        console.log(JSON.stringify(policy, null, 2));
+        break;
+      }
+
+      case "referrals": {
+        const client = await getClient();
+        const info = await client.getReferrals();
+        console.log(JSON.stringify(info, null, 2));
+        break;
+      }
+
+      case "pulse": {
+        const pulse = await AgentWallet.getNetworkPulse();
+        console.log(JSON.stringify(pulse, null, 2));
+        break;
+      }
+
+      case "disconnect": {
+        const storage = new FileCredentialStorage();
+        await storage.delete();
+        console.log("Credentials cleared.");
+        break;
+      }
+
+      case "config": {
+        const storage = new FileCredentialStorage();
+        console.log(storage.getPath());
+        break;
+      }
+
+      case "help":
+      case undefined:
+        usage();
+        break;
+
+      default:
+        console.error(`Unknown command: ${command}`);
+        usage();
+        process.exit(1);
+    }
+  } catch (err) {
+    if (err instanceof AgentWalletError) {
+      console.error(`Error: ${err.message}`);
+      if (err.hint) {
+        console.error(`Hint: ${err.hint}`);
+      }
+      if (err.code && err.code !== "API_ERROR" && err.code !== "AGENT_WALLET_ERROR") {
+        console.error(`Code: ${err.code}`);
+      }
+    } else if (err instanceof Error) {
+      console.error(`Error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+run();

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "references": [
+    { "path": "../sdk" }
+  ]
+}