@sly_ai/cli 0.1.0

package/src/commands/ap2.ts

@@ -0,0 +1,134 @@
+import { Command } from 'commander';
+import { createClient } from '../utils/auth.js';
+import { output, error } from '../utils/output.js';
+
+export function registerAP2Commands(program: Command) {
+  const cmd = program.command('ap2').description('AP2 (Agent-to-Agent Protocol) mandate-based payments');
+
+  cmd
+    .command('mandates')
+    .description('List mandates')
+    .option('--status <status>', 'Filter by status (active, completed, cancelled, expired)')
+    .option('--agent-id <agentId>', 'Filter by agent ID')
+    .option('--account-id <accountId>', 'Filter by account ID')
+    .option('--limit <limit>', 'Max results', parseInt)
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const result = await sly.ap2.listMandates({
+          status: opts.status,
+          agent_id: opts.agentId,
+          account_id: opts.accountId,
+          limit: opts.limit,
+        });
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('get <mandateId>')
+    .description('Get mandate details with execution history')
+    .action(async (mandateId) => {
+      try {
+        const sly = createClient();
+        const result = await sly.ap2.getMandate(mandateId);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('create')
+    .description('Create a spending mandate for an agent')
+    .requiredOption('--mandate-id <mandateId>', 'Unique mandate identifier')
+    .requiredOption('--agent-id <agentId>', 'UUID of the agent')
+    .requiredOption('--account-id <accountId>', 'UUID of the funding account')
+    .requiredOption('--authorized-amount <amount>', 'Maximum spending amount', parseFloat)
+    .option('--currency <currency>', 'Currency (default: USD)')
+    .option('--mandate-type <type>', 'Type: intent, cart, or payment (default: payment)')
+    .option('--description <description>', 'Human-readable description')
+    .option('--expires-at <date>', 'ISO 8601 expiration timestamp')
+    .option('--metadata <json>', 'Metadata as JSON string')
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const body: Record<string, unknown> = {
+          mandate_id: opts.mandateId,
+          agent_id: opts.agentId,
+          account_id: opts.accountId,
+          authorized_amount: opts.authorizedAmount,
+        };
+        if (opts.currency) body.currency = opts.currency;
+        if (opts.mandateType) body.mandate_type = opts.mandateType;
+        if (opts.description) body.description = opts.description;
+        if (opts.expiresAt) body.expires_at = opts.expiresAt;
+        if (opts.metadata) body.metadata = JSON.parse(opts.metadata);
+        const result = await sly.ap2.createMandate(body as Parameters<typeof sly.ap2.createMandate>[0]);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('execute <mandateId>')
+    .description('Execute a payment against a mandate')
+    .requiredOption('--amount <amount>', 'Amount to pay', parseFloat)
+    .option('--currency <currency>', 'Currency')
+    .option('--description <description>', 'Description of this payment')
+    .action(async (mandateId, opts) => {
+      try {
+        const sly = createClient();
+        const body: Record<string, unknown> = { amount: opts.amount };
+        if (opts.currency) body.currency = opts.currency;
+        if (opts.description) body.description = opts.description;
+        const result = await sly.ap2.executeMandate(mandateId, body as Parameters<typeof sly.ap2.executeMandate>[1]);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('cancel <mandateId>')
+    .description('Cancel an active mandate')
+    .action(async (mandateId) => {
+      try {
+        const sly = createClient();
+        const result = await sly.ap2.cancelMandate(mandateId);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('update <mandateId>')
+    .description('Update a mandate')
+    .option('--authorized-amount <amount>', 'New authorized amount', parseFloat)
+    .option('--status <status>', 'New status')
+    .option('--expires-at <date>', 'New expiration (ISO 8601)')
+    .option('--description <description>', 'Updated description')
+    .option('--metadata <json>', 'Updated metadata as JSON string')
+    .action(async (mandateId, opts) => {
+      try {
+        const sly = createClient();
+        const body: Record<string, unknown> = {};
+        if (opts.authorizedAmount !== undefined) body.authorized_amount = opts.authorizedAmount;
+        if (opts.status) body.status = opts.status;
+        if (opts.expiresAt) body.expires_at = opts.expiresAt;
+        if (opts.description) body.description = opts.description;
+        if (opts.metadata) body.metadata = JSON.parse(opts.metadata);
+        const result = await sly.request(`/v1/ap2/mandates/${mandateId}`, {
+          method: 'PATCH',
+          body: JSON.stringify(body),
+        });
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+}

package/src/commands/env.ts

@@ -0,0 +1,66 @@
+import { Command } from 'commander';
+import { output, error } from '../utils/output.js';
+
+export function registerEnvCommands(program: Command) {
+  const cmd = program.command('env').description('Environment management');
+
+  cmd
+    .command('get')
+    .description('Show current environment info')
+    .action(() => {
+      try {
+        const apiKey = process.env.SLY_API_KEY;
+        if (!apiKey) {
+          error('SLY_API_KEY environment variable is not set');
+        }
+
+        const environment = apiKey.startsWith('pk_live_') ? 'production' : 'sandbox';
+        const masked = apiKey.slice(0, 12) + '***';
+
+        output({
+          environment,
+          apiKeyPrefix: masked,
+          apiUrl: process.env.SLY_API_URL || (environment === 'production' ? 'https://api.getsly.ai' : 'https://sandbox.getsly.ai'),
+        });
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('switch <environment>')
+    .description('Show instructions for switching between sandbox and production')
+    .action((environment) => {
+      if (environment !== 'sandbox' && environment !== 'production') {
+        error('Environment must be "sandbox" or "production"');
+      }
+
+      const prefix = environment === 'production' ? 'pk_live_' : 'pk_test_';
+      console.log(`To switch to ${environment}, set your API key:`);
+      console.log(`  export SLY_API_KEY=${prefix}your_key_here`);
+      if (environment === 'production') {
+        console.log(`  export SLY_API_URL=https://api.getsly.ai`);
+      } else {
+        console.log(`  export SLY_API_URL=https://sandbox.getsly.ai`);
+      }
+    });
+
+  cmd
+    .command('whoami')
+    .description('Get information about the current tenant/organization')
+    .action(async () => {
+      try {
+        const apiKey = process.env.SLY_API_KEY;
+        if (!apiKey) {
+          error('SLY_API_KEY environment variable is not set');
+        }
+        // Lazy import to avoid requiring SLY_API_KEY for non-API commands
+        const { createClient } = await import('../utils/auth.js');
+        const sly = createClient();
+        const result = await sly.request('/v1/context/whoami');
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+}

package/src/commands/merchants.ts

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { createClient } from '../utils/auth.js';
+import { output, error } from '../utils/output.js';
+
+export function registerMerchantsCommands(program: Command) {
+  const cmd = program.command('merchants').description('Browse merchant catalogs');
+
+  cmd
+    .command('list')
+    .description('List merchants with product catalogs')
+    .option('--type <type>', 'Merchant type filter (e.g., restaurant, bar, hotel, retail)')
+    .option('--country <country>', 'Country code filter (e.g., PA, CR)')
+    .option('--search <search>', 'Search merchants by name')
+    .option('--limit <limit>', 'Max results (default 50, max 100)', parseInt)
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const params = new URLSearchParams();
+        if (opts.type) params.set('type', opts.type);
+        if (opts.country) params.set('country', opts.country);
+        if (opts.search) params.set('search', opts.search);
+        if (opts.limit) params.set('limit', String(opts.limit));
+        const qs = params.toString();
+        const result = await sly.request(`/v1/ucp/merchants${qs ? `?${qs}` : ''}`);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('get <merchantId>')
+    .description('Get a merchant\'s full product catalog')
+    .action(async (merchantId) => {
+      try {
+        const sly = createClient();
+        const result = await sly.request(`/v1/ucp/merchants/${merchantId}`);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+}

package/src/commands/mpp.ts

@@ -0,0 +1,144 @@
+import { Command } from 'commander';
+import { createClient } from '../utils/auth.js';
+import { output, error } from '../utils/output.js';
+
+export function registerMPPCommands(program: Command) {
+  const cmd = program.command('mpp').description('MPP (Machine Payments Protocol) sessions and payments');
+
+  cmd
+    .command('sessions')
+    .description('List MPP sessions')
+    .option('--agent-id <agentId>', 'Filter by agent ID')
+    .option('--status <status>', 'Filter by status (active, closed, expired, exhausted)')
+    .option('--limit <limit>', 'Results per page', parseInt)
+    .option('--offset <offset>', 'Offset for pagination', parseInt)
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const result = await sly.mpp.listSessions({
+          agent_id: opts.agentId,
+          status: opts.status,
+          limit: opts.limit,
+          offset: opts.offset,
+        });
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('get-session <id>')
+    .description('Get MPP session details with voucher history')
+    .action(async (id) => {
+      try {
+        const sly = createClient();
+        const result = await sly.mpp.getSession(id);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('open')
+    .description('Open a streaming MPP payment session')
+    .requiredOption('--service-url <url>', 'URL of the service')
+    .requiredOption('--deposit-amount <amount>', 'Initial deposit amount', parseFloat)
+    .requiredOption('--agent-id <agentId>', 'UUID of the agent')
+    .requiredOption('--wallet-id <walletId>', 'UUID of the wallet')
+    .option('--max-budget <amount>', 'Maximum total budget', parseFloat)
+    .option('--currency <currency>', 'Currency (default: USDC)')
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const body: Record<string, unknown> = {
+          service_url: opts.serviceUrl,
+          deposit_amount: opts.depositAmount,
+          agent_id: opts.agentId,
+          wallet_id: opts.walletId,
+        };
+        if (opts.maxBudget !== undefined) body.max_budget = opts.maxBudget;
+        if (opts.currency) body.currency = opts.currency;
+        const result = await sly.mpp.openSession(body as Parameters<typeof sly.mpp.openSession>[0]);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('pay')
+    .description('Make a one-shot MPP payment to a service')
+    .requiredOption('--service-url <url>', 'URL of the service to pay')
+    .requiredOption('--amount <amount>', 'Payment amount', parseFloat)
+    .requiredOption('--agent-id <agentId>', 'UUID of the agent making the payment')
+    .option('--wallet-id <walletId>', 'UUID of the wallet to pay from')
+    .option('--currency <currency>', 'Currency (default: USDC)')
+    .option('--intent <intent>', 'Description of what the payment is for')
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const body: Record<string, unknown> = {
+          service_url: opts.serviceUrl,
+          amount: opts.amount,
+          agent_id: opts.agentId,
+        };
+        if (opts.walletId) body.wallet_id = opts.walletId;
+        if (opts.currency) body.currency = opts.currency;
+        if (opts.intent) body.intent = opts.intent;
+        const result = await sly.mpp.pay(body as Parameters<typeof sly.mpp.pay>[0]);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('close <sessionId>')
+    .description('Close an active MPP session')
+    .action(async (sessionId) => {
+      try {
+        const sly = createClient();
+        const result = await sly.mpp.closeSession(sessionId);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('transfers')
+    .description('List MPP payment transfers')
+    .option('--service-url <url>', 'Filter by service URL')
+    .option('--session-id <id>', 'Filter by session ID')
+    .option('--limit <limit>', 'Results per page', parseInt)
+    .option('--offset <offset>', 'Offset for pagination', parseInt)
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const result = await sly.mpp.listTransfers({
+          service_url: opts.serviceUrl,
+          session_id: opts.sessionId,
+          limit: opts.limit,
+          offset: opts.offset,
+        });
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('verify-receipt <receiptId>')
+    .description('Verify an MPP payment receipt')
+    .action(async (receiptId) => {
+      try {
+        const sly = createClient();
+        const result = await sly.mpp.verifyReceipt(receiptId);
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+}

package/src/commands/settlement.ts

@@ -0,0 +1,63 @@
+import { Command } from 'commander';
+import { createClient } from '../utils/auth.js';
+import { output, error } from '../utils/output.js';
+
+export function registerSettlementCommands(program: Command) {
+  const cmd = program.command('settlement').description('Manage settlements and FX quotes');
+
+  cmd
+    .command('quote')
+    .description('Get a settlement quote with FX rates and fees')
+    .requiredOption('--from-currency <currency>', 'Source currency (USD, BRL, MXN, USDC)')
+    .requiredOption('--to-currency <currency>', 'Destination currency (USD, BRL, MXN, USDC)')
+    .requiredOption('--amount <amount>', 'Amount to convert')
+    .option('--rail <rail>', 'Settlement rail (pix, spei, wire, usdc)')
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const quote = await sly.getSettlementQuote({
+          fromCurrency: opts.fromCurrency,
+          toCurrency: opts.toCurrency,
+          amount: opts.amount,
+          rail: opts.rail,
+        });
+        output(quote);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('create')
+    .description('Execute a settlement using a quote')
+    .requiredOption('--quote-id <quoteId>', 'Quote ID from settlement quote')
+    .requiredOption('--destination-account-id <accountId>', 'Destination account ID')
+    .option('--metadata <json>', 'Optional metadata as JSON string')
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const body: Record<string, unknown> = {
+          quoteId: opts.quoteId,
+          destinationAccountId: opts.destinationAccountId,
+        };
+        if (opts.metadata) body.metadata = JSON.parse(opts.metadata);
+        const settlement = await sly.createSettlement(body as Parameters<typeof sly.createSettlement>[0]);
+        output(settlement);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('status <id>')
+    .description('Check the status of a settlement')
+    .action(async (id) => {
+      try {
+        const sly = createClient();
+        const settlement = await sly.getSettlement(id);
+        output(settlement);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+}

package/src/commands/support.ts

@@ -0,0 +1,110 @@
+import { Command } from 'commander';
+import { createClient } from '../utils/auth.js';
+import { output, error } from '../utils/output.js';
+
+export function registerSupportCommands(program: Command) {
+  const cmd = program.command('support').description('Support and dispute management');
+
+  cmd
+    .command('explain-rejection')
+    .description('Explain why a transaction was rejected')
+    .option('--error-code <code>', 'Error code from the rejection')
+    .option('--transaction-id <id>', 'UUID of the rejected transaction')
+    .option('--agent-id <id>', 'UUID of the agent')
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const body: Record<string, unknown> = {};
+        if (opts.errorCode) body.error_code = opts.errorCode;
+        if (opts.transactionId) body.transaction_id = opts.transactionId;
+        if (opts.agentId) body.agent_id = opts.agentId;
+        const result = await sly.request('/v1/support/explain-rejection', {
+          method: 'POST',
+          body: JSON.stringify(body),
+        });
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('request-limit-increase')
+    .description('Submit a request to increase an agent\'s spending limit')
+    .requiredOption('--agent-id <agentId>', 'UUID of the agent')
+    .requiredOption('--limit-type <type>', 'Which limit to increase (per_transaction, daily, monthly)')
+    .requiredOption('--requested-amount <amount>', 'The new desired limit amount (USD)', parseFloat)
+    .requiredOption('--reason <reason>', 'Business justification')
+    .option('--duration <duration>', 'How long the increase should last (temporary_24h, temporary_7d, permanent)')
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const body: Record<string, unknown> = {
+          agent_id: opts.agentId,
+          limit_type: opts.limitType,
+          requested_amount: opts.requestedAmount,
+          reason: opts.reason,
+        };
+        if (opts.duration) body.duration = opts.duration;
+        const result = await sly.request('/v1/support/request-limit-increase', {
+          method: 'POST',
+          body: JSON.stringify(body),
+        });
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('open-dispute')
+    .description('Open a dispute for a completed transaction')
+    .requiredOption('--transaction-id <id>', 'UUID of the transaction')
+    .requiredOption('--reason <reason>', 'Reason (service_not_received, duplicate_charge, unauthorized, amount_incorrect, quality_issue, other)')
+    .requiredOption('--description <description>', 'Detailed description of the issue')
+    .option('--requested-resolution <resolution>', 'Requested resolution (full_refund, partial_refund, credit, other)')
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const body: Record<string, unknown> = {
+          transaction_id: opts.transactionId,
+          reason: opts.reason,
+          description: opts.description,
+        };
+        if (opts.requestedResolution) body.requested_resolution = opts.requestedResolution;
+        const result = await sly.request('/v1/support/open-dispute', {
+          method: 'POST',
+          body: JSON.stringify(body),
+        });
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+
+  cmd
+    .command('escalate')
+    .description('Escalate an issue to a human support operator')
+    .requiredOption('--reason <reason>', 'Why this is being escalated (complex_issue, agent_requested, security_concern, policy_exception, bug_report)')
+    .requiredOption('--summary <summary>', 'Summary of the issue')
+    .option('--agent-id <agentId>', 'UUID of the agent')
+    .option('--priority <priority>', 'Priority level (low, medium, high, critical)')
+    .action(async (opts) => {
+      try {
+        const sly = createClient();
+        const body: Record<string, unknown> = {
+          reason: opts.reason,
+          summary: opts.summary,
+        };
+        if (opts.agentId) body.agent_id = opts.agentId;
+        if (opts.priority) body.priority = opts.priority;
+        const result = await sly.request('/v1/support/escalate', {
+          method: 'POST',
+          body: JSON.stringify(body),
+        });
+        output(result);
+      } catch (e: unknown) {
+        error((e as Error).message);
+      }
+    });
+}