@sly_ai/cli 0.1.0

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@sly_ai/cli",
+  "version": "0.1.0",
+  "description": "Sly CLI — command-line interface for the Sly agentic economy platform",
+  "type": "module",
+  "bin": {
+    "sly": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@sly/sdk": "workspace:*",
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/commands/a2a.ts

@@ -0,0 +1,110 @@
+import { Command } from 'commander';
+import { createClient } from '../utils/auth.js';
+import { output, error } from '../utils/output.js';
+
+export function registerA2ACommands(program: Command) {
+  const cmd = program.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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).message);
+      }
+    });
+}

package/src/commands/accounts.ts

@@ -0,0 +1,85 @@
+import { Command } from 'commander';
+import { createClient } from '../utils/auth.js';
+import { output, error } from '../utils/output.js';
+
+export function registerAccountsCommands(program: Command) {
+  const cmd = program.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: unknown) {
+        error((e as Error).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: Record<string, unknown> = { 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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: Record<string, unknown> = {};
+        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: unknown) {
+        error((e as Error).message);
+      }
+    });
+}

package/src/commands/acp.ts

@@ -0,0 +1,104 @@
+import { Command } from 'commander';
+import { createClient } from '../utils/auth.js';
+import { output, error } from '../utils/output.js';
+
+export function registerACPCommands(program: Command) {
+  const cmd = program.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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: Record<string, unknown> = {
+          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 !== undefined) body.tax_amount = opts.taxAmount;
+        if (opts.shippingAmount !== undefined) body.shipping_amount = opts.shippingAmount;
+        if (opts.paymentMethod) body.payment_method = opts.paymentMethod;
+        const result = await sly.acp.createCheckout(body as Parameters<typeof sly.acp.createCheckout>[0]);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).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: Record<string, unknown> = {};
+        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 as Parameters<typeof sly.acp.completeCheckout>[1]);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).message);
+      }
+    });
+}

package/src/commands/agent-wallets.ts

@@ -0,0 +1,127 @@
+import { Command } from 'commander';
+import { createClient } from '../utils/auth.js';
+import { output, error } from '../utils/output.js';
+
+export function registerAgentWalletsCommands(program: Command) {
+  const cmd = program.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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: Record<string, unknown> = {};
+        if (opts.dailySpendLimit !== undefined) policy.dailySpendLimit = opts.dailySpendLimit;
+        if (opts.monthlySpendLimit !== undefined) policy.monthlySpendLimit = opts.monthlySpendLimit;
+        if (opts.requiresApprovalAbove !== undefined) 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 as Parameters<typeof sly.agentWallets.setContractPolicy>[1]);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+}

package/src/commands/agents.ts

@@ -0,0 +1,110 @@
+import { Command } from 'commander';
+import { createClient } from '../utils/auth.js';
+import { output, error } from '../utils/output.js';
+
+export function registerAgentsCommands(program: Command) {
+  const cmd = program.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: Record<string, unknown> = {
+          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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).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: unknown) {
+        error((e as Error).message);
+      }
+    });
+}