@sly_ai/cli 0.1.0

package/src/commands/ucp.ts

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

package/src/commands/wallets.ts

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

package/src/commands/x402.ts

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

package/src/index.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerAccountsCommands } from './commands/accounts.js';
+import { registerAgentsCommands } from './commands/agents.js';
+import { registerWalletsCommands } from './commands/wallets.js';
+import { registerSettlementCommands } from './commands/settlement.js';
+import { registerX402Commands } from './commands/x402.js';
+import { registerAP2Commands } from './commands/ap2.js';
+import { registerACPCommands } from './commands/acp.js';
+import { registerUCPCommands } from './commands/ucp.js';
+import { registerMPPCommands } from './commands/mpp.js';
+import { registerA2ACommands } from './commands/a2a.js';
+import { registerAgentWalletsCommands } from './commands/agent-wallets.js';
+import { registerMerchantsCommands } from './commands/merchants.js';
+import { registerSupportCommands } from './commands/support.js';
+import { registerEnvCommands } from './commands/env.js';
+
+const program = new Command()
+  .name('sly')
+  .description('Sly CLI — 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();

package/src/utils/auth.ts

@@ -0,0 +1,14 @@
+import { Sly } from '@sly/sdk';
+
+export function createClient(): Sly {
+  const apiKey = process.env.SLY_API_KEY;
+  if (!apiKey) {
+    console.error('Error: SLY_API_KEY environment variable is required');
+    console.error('Set it with: export SLY_API_KEY=pk_test_...');
+    process.exit(1);
+  }
+  return new Sly({
+    apiKey,
+    apiUrl: process.env.SLY_API_URL,
+  });
+}

package/src/utils/output.ts

@@ -0,0 +1,8 @@
+export function output(data: unknown): void {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function error(message: string): never {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2020"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}