arispay 0.1.0

package/src/cli-shared.ts

@@ -0,0 +1,650 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { ArisPay } from './index.js';
+import type { ArisPayClient } from './index.js';
+
+// ── Branding ────────────────────────────────────────────────────────
+
+export interface Brand {
+  cmd: string;       // "arispay" or "payagent"
+  configDir: string; // "~/.arispay" or "~/.payagent"
+  envPrefix: string; // "ARISPAY" or "PAYAGENT"
+  authHint: string;  // "arispay init" or "payagent login"
+}
+
+export function createBrand(cmd: string, authHint: string): Brand {
+  const configDir = join(homedir(), `.${cmd}`);
+  const envPrefix = cmd.toUpperCase();
+  return { cmd, configDir, envPrefix, authHint };
+}
+
+// ── Config ──────────────────────────────────────────────────────────
+
+export interface Config {
+  apiKey?: string;
+  environment?: 'sandbox' | 'production';
+  baseUrl?: string;
+  // PayAgent (browser login) fields
+  accessToken?: string;
+  refreshToken?: string;
+  expiresAt?: number;
+  email?: string;
+}
+
+export function configFile(brand: Brand): string {
+  return join(brand.configDir, 'config.json');
+}
+
+export function loadConfig(brand: Brand): Config {
+  const file = configFile(brand);
+  const fileConfig: Config = existsSync(file)
+    ? JSON.parse(readFileSync(file, 'utf-8'))
+    : {};
+
+  return {
+    ...fileConfig,
+    apiKey: env(`${brand.envPrefix}_API_KEY`) || fileConfig.apiKey,
+    environment: (env(`${brand.envPrefix}_ENV`) as Config['environment']) || fileConfig.environment || 'sandbox',
+    baseUrl: env(`${brand.envPrefix}_BASE_URL`) || fileConfig.baseUrl,
+  };
+}
+
+export function saveConfig(brand: Brand, config: Config): void {
+  if (!existsSync(brand.configDir)) mkdirSync(brand.configDir, { recursive: true });
+  writeFileSync(configFile(brand), JSON.stringify(config, null, 2) + '\n');
+}
+
+export function getClient(brand: Brand): ArisPayClient {
+  const config = loadConfig(brand);
+  const key = config.apiKey || config.accessToken;
+  if (!key) {
+    error(`No credentials configured. Run: ${brand.authHint}`);
+  }
+  return ArisPay.init({
+    apiKey: key!,
+    environment: config.environment,
+    baseUrl: config.baseUrl,
+  });
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+export function env(key: string): string | undefined {
+  return process.env[key];
+}
+
+export function error(msg: string): never {
+  console.error(`\x1b[31m✗\x1b[0m ${msg}`);
+  process.exit(1);
+}
+
+export function success(msg: string): void {
+  console.log(`\x1b[32m✓\x1b[0m ${msg}`);
+}
+
+export function dim(msg: string): string {
+  return `\x1b[2m${msg}\x1b[0m`;
+}
+
+export function bold(msg: string): string {
+  return `\x1b[1m${msg}\x1b[0m`;
+}
+
+export function cyan(msg: string): string {
+  return `\x1b[36m${msg}\x1b[0m`;
+}
+
+export function yellow(msg: string): string {
+  return `\x1b[33m${msg}\x1b[0m`;
+}
+
+export function json(data: unknown): void {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function table(rows: Record<string, unknown>[]): void {
+  if (rows.length === 0) {
+    console.log(dim('  (none)'));
+    return;
+  }
+  const keys = Object.keys(rows[0]);
+  const widths = keys.map((k) =>
+    Math.max(k.length, ...rows.map((r) => String(r[k] ?? '').length)),
+  );
+
+  console.log(keys.map((k, i) => bold(k.padEnd(widths[i]))).join('  '));
+  console.log(widths.map((w) => '─'.repeat(w)).join('──'));
+
+  for (const row of rows) {
+    console.log(keys.map((k, i) => String(row[k] ?? '').padEnd(widths[i])).join('  '));
+  }
+}
+
+export function prompt(question: string): Promise<string> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export function promptSecret(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+    const rl = createInterface({ input: process.stdin, terminal: false });
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode?.(true);
+    }
+    let input = '';
+    const onData = (ch: Buffer) => {
+      const c = ch.toString();
+      if (c === '\n' || c === '\r') {
+        process.stdin.removeListener('data', onData);
+        if (process.stdin.isTTY) process.stdin.setRawMode?.(false);
+        rl.close();
+        process.stdout.write('\n');
+        resolve(input.trim());
+      } else if (c === '\u007f' || c === '\b') {
+        input = input.slice(0, -1);
+      } else if (c === '\u0003') {
+        process.exit(0);
+      } else {
+        input += c;
+      }
+    };
+    if (process.stdin.isTTY) {
+      process.stdin.resume();
+      process.stdin.on('data', onData);
+    } else {
+      rl.on('line', (line) => {
+        rl.close();
+        resolve(line.trim());
+      });
+    }
+  });
+}
+
+export function parseFlags(args: string[]): { flags: Record<string, string>; positional: string[] } {
+  const flags: Record<string, string> = {};
+  const positional: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx !== -1) {
+        flags[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else {
+        flags[arg.slice(2)] = args[++i] ?? 'true';
+      }
+    } else if (arg.startsWith('-') && arg.length === 2) {
+      flags[arg.slice(1)] = args[++i] ?? 'true';
+    } else {
+      positional.push(arg);
+    }
+  }
+
+  return { flags, positional };
+}
+
+export function requireFlag(flags: Record<string, string>, key: string, label?: string): string {
+  const val = flags[key];
+  if (!val) error(`Missing required flag: --${key}${label ? ` (${label})` : ''}`);
+  return val;
+}
+
+// ── Shared Commands ─────────────────────────────────────────────────
+
+export async function cmdAgents(args: string[], brand: Brand): Promise<void> {
+  const [sub, ...rest] = args;
+  if (!sub || sub === 'help' || sub === '--help') {
+    return cmdAgentsHelp(brand);
+  }
+  const { flags, positional } = parseFlags(rest);
+  const client = getClient(brand);
+  const $ = brand.cmd;
+
+  switch (sub) {
+    case 'list':
+    case 'ls': {
+      const agents = await client.agents.list({
+        limit: flags['limit'] ? Number(flags['limit']) : 20,
+        offset: flags['offset'] ? Number(flags['offset']) : undefined,
+        status: flags['status'],
+        name: flags['name'],
+      });
+      table(
+        (agents as any).agents?.map((a: any) => ({
+          id: a.id.slice(0, 12) + '…',
+          name: a.name,
+          mode: a.mode || 'platform',
+          status: a.status,
+          created: a.createdAt?.slice(0, 10),
+        })) ?? [],
+      );
+      break;
+    }
+
+    case 'create': {
+      const name = flags['name'] || positional[0];
+      if (!name) error(`Usage: ${$} agents create --name <name> [--mode platform|autonomous]`);
+      const agent = await client.agents.register({
+        name,
+        description: flags['description'],
+        permissions: (flags['permissions'] || 'browse,payment').split(',') as any,
+        mode: (flags['mode'] as 'platform' | 'autonomous') || undefined,
+        sweepThreshold: flags['sweep-threshold'] ? Number(flags['sweep-threshold']) : undefined,
+      });
+      success(`Agent created: ${(agent as any).id}`);
+      json(agent);
+      break;
+    }
+
+    case 'get': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} agents get <id>`);
+      const agent = await client.agents.get(id);
+      json(agent);
+      break;
+    }
+
+    case 'rotate-keys': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} agents rotate-keys <id>`);
+      const result = await client.agents.rotateKeys(id);
+      success('Keys rotated');
+      json(result);
+      break;
+    }
+
+    case 'balance': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} agents balance <id>`);
+      const balance = await client.agents.getBalance(id);
+      const cents = (balance as any).balance ?? (balance as any).balanceCents ?? 0;
+      console.log(`\n  ${bold('Balance:')} ${cyan('$' + (cents / 100).toFixed(2))} ${(balance as any).currency || 'USD'}\n`);
+      break;
+    }
+
+    case 'ledger': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} agents ledger <id>`);
+      const ledger = await client.agents.getLedger(id, {
+        limit: flags['limit'] ? Number(flags['limit']) : 20,
+      });
+      table(
+        ((ledger as any).entries ?? []).map((e: any) => ({
+          type: e.type,
+          direction: e.direction,
+          amount: '$' + (e.amount / 100).toFixed(2),
+          balance: '$' + (e.balanceAfter / 100).toFixed(2),
+          description: (e.description || '').slice(0, 30),
+          date: e.createdAt?.slice(0, 10),
+        })),
+      );
+      break;
+    }
+
+    case 'topup': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} agents topup <id> --amount <cents> --user <userId>`);
+      const amount = Number(requireFlag(flags, 'amount', 'in cents'));
+      const userId = requireFlag(flags, 'user', 'end user ID');
+      const result = await client.agents.topup(id, { amount, userId });
+      success(`Topped up $${(amount / 100).toFixed(2)}`);
+      json(result);
+      break;
+    }
+
+    case 'sweep': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} agents sweep <id> [--amount <cents>]`);
+      const result = await client.agents.sweep(id, {
+        amount: flags['amount'] ? Number(flags['amount']) : undefined,
+      });
+      success('Sweep complete');
+      json(result);
+      break;
+    }
+
+    case 'resume': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} agents resume <id>`);
+      const result = await client.agents.resume(id);
+      success(`Agent resumed at ${(result as any).resumedAt}`);
+      break;
+    }
+
+    default:
+      cmdAgentsHelp(brand);
+  }
+}
+
+function cmdAgentsHelp(brand: Brand): void {
+  const $ = brand.cmd;
+  console.log(`
+${bold(`${$} agents`)} — Manage AI payment agents
+
+  ${cyan(`${$} agents list`)}          List agents
+  ${cyan(`${$} agents create`)}        Register a new agent
+  ${cyan(`${$} agents get <id>`)}      Get agent details
+  ${cyan(`${$} agents balance <id>`)}  Check agent balance
+  ${cyan(`${$} agents ledger <id>`)}   View agent ledger
+  ${cyan(`${$} agents topup <id>`)}    Fund agent from user's card
+  ${cyan(`${$} agents sweep <id>`)}    Withdraw agent balance
+  ${cyan(`${$} agents rotate-keys <id>`)}  Rotate TAP keypair
+  ${cyan(`${$} agents resume <id>`)}   Resume suspended agent
+`);
+}
+
+export async function cmdUsers(args: string[], brand: Brand): Promise<void> {
+  const [sub, ...rest] = args;
+  if (!sub || sub === 'help' || sub === '--help') {
+    return cmdUsersHelp(brand);
+  }
+  const { flags, positional } = parseFlags(rest);
+  const client = getClient(brand);
+  const $ = brand.cmd;
+
+  switch (sub) {
+    case 'create': {
+      const externalId = flags['external-id'] || positional[0];
+      if (!externalId) error(`Usage: ${$} users create --external-id <id> [--email <email>]`);
+      const user = await client.users.create({
+        externalId,
+        email: flags['email'],
+      });
+      success(`User created: ${(user as any).id}`);
+      json(user);
+      break;
+    }
+
+    case 'get': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} users get <id>`);
+      const user = await client.users.get(id);
+      json(user);
+      break;
+    }
+
+    case 'find': {
+      const externalId = flags['external-id'] || positional[0];
+      if (!externalId) error(`Usage: ${$} users find <externalId>`);
+      const user = await client.users.getByExternalId(externalId);
+      json(user);
+      break;
+    }
+
+    case 'add-card': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} users add-card <userId> --return-url <url>`);
+      const returnUrl = requireFlag(flags, 'return-url');
+      const result = await client.users.addPaymentMethod({
+        userId: id,
+        type: 'card',
+        returnUrl,
+      });
+      success('Card setup initiated');
+      console.log(`\n  ${bold('Setup URL:')} ${(result as any).setupUrl}`);
+      console.log(`  ${bold('Session ID:')} ${(result as any).sessionId}\n`);
+      break;
+    }
+
+    case 'add-wallet': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} users add-wallet <userId> --address <addr> --chain <chain>`);
+      const walletAddress = requireFlag(flags, 'address', 'wallet address');
+      const chain = requireFlag(flags, 'chain', 'ethereum|base|polygon|solana');
+      const result = await client.users.addPaymentMethod({
+        userId: id,
+        type: 'wallet',
+        walletAddress,
+        chain: chain as any,
+      });
+      success('Wallet registered');
+      json(result);
+      break;
+    }
+
+    case 'set-limits': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} users set-limits <userId> --agent <agentId> [--per-tx <cents>] [--daily <cents>] [--monthly <cents>]`);
+      const agentId = requireFlag(flags, 'agent', 'agent ID');
+      const result = await client.users.setLimits({
+        userId: id,
+        agentId,
+        maxPerTransaction: flags['per-tx'] ? Number(flags['per-tx']) : undefined,
+        maxDaily: flags['daily'] ? Number(flags['daily']) : undefined,
+        maxMonthly: flags['monthly'] ? Number(flags['monthly']) : undefined,
+      });
+      success('Spend limits updated');
+      json(result);
+      break;
+    }
+
+    case 'wallet-status': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} users wallet-status <userId>`);
+      const status = await client.users.getWalletStatus(id);
+      json(status);
+      break;
+    }
+
+    default:
+      cmdUsersHelp(brand);
+  }
+}
+
+function cmdUsersHelp(brand: Brand): void {
+  const $ = brand.cmd;
+  console.log(`
+${bold(`${$} users`)} — Manage end users & payment methods
+
+  ${cyan(`${$} users create`)}          Create end user
+  ${cyan(`${$} users get <id>`)}        Get user by ID
+  ${cyan(`${$} users find <extId>`)}    Find user by external ID
+  ${cyan(`${$} users add-card <id>`)}   Start card tokenization
+  ${cyan(`${$} users add-wallet <id>`)} Register crypto wallet
+  ${cyan(`${$} users set-limits <id>`)} Set spend limits
+  ${cyan(`${$} users wallet-status <id>`)} Check wallet USDC status
+`);
+}
+
+export async function cmdPay(args: string[], brand: Brand): Promise<void> {
+  const { flags } = parseFlags(args);
+  const client = getClient(brand);
+
+  const agentId = requireFlag(flags, 'agent', 'agent ID');
+  const amount = Number(requireFlag(flags, 'amount', 'amount in cents'));
+  const currency = flags['currency'] || 'USD';
+  const memo = requireFlag(flags, 'memo', 'payment memo');
+  const idempotencyKey = flags['idempotency-key'] || `cli_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+
+  const params: any = {
+    agentId,
+    amount,
+    currency,
+    memo,
+    idempotencyKey,
+  };
+
+  if (flags['user']) params.userId = flags['user'];
+  if (flags['merchant-url']) params.merchantUrl = flags['merchant-url'];
+  if (flags['merchant-name']) params.merchantName = flags['merchant-name'];
+  if (flags['rail']) params.rail = flags['rail'];
+  if (flags['chain']) params.chain = flags['chain'];
+  if (flags['recipient']) params.recipientAddress = flags['recipient'];
+  if (flags['token']) params.token = flags['token'];
+  if (flags['metadata']) {
+    try {
+      params.metadata = JSON.parse(flags['metadata']);
+    } catch {
+      error('--metadata must be valid JSON');
+    }
+  }
+
+  console.log(`\n  ${dim('Creating payment...')}\n`);
+  const payment = await client.payments.create(params);
+
+  const p = payment as any;
+  if (p.status === 'succeeded') {
+    success(`Payment ${bold(p.id)} — $${(amount / 100).toFixed(2)} ${currency}`);
+  } else if (p.status === 'requires_action') {
+    console.log(`  ${bold('Status:')} requires_action (3DS)`);
+    if (p.nextAction?.type === 'redirect') {
+      console.log(`  ${bold('Redirect:')} ${p.nextAction.url}`);
+    }
+  } else {
+    console.log(`  ${bold('Status:')} ${p.status}`);
+  }
+
+  console.log();
+  json(payment);
+}
+
+export async function cmdPaymentGet(args: string[], brand: Brand): Promise<void> {
+  const { positional } = parseFlags(args);
+  const id = positional[0];
+  if (!id) error(`Usage: ${brand.cmd} payment <id>`);
+  const client = getClient(brand);
+  const payment = await client.payments.get(id);
+  json(payment);
+}
+
+export async function cmdTransactions(args: string[], brand: Brand): Promise<void> {
+  const { flags } = parseFlags(args);
+  const client = getClient(brand);
+
+  const result = await client.transactions.list({
+    agentId: flags['agent'],
+    userId: flags['user'],
+    from: flags['from'],
+    to: flags['to'],
+    limit: flags['limit'] ? Number(flags['limit']) : 20,
+    offset: flags['offset'] ? Number(flags['offset']) : undefined,
+  });
+
+  const payments = (result as any).payments ?? (result as any).transactions ?? [];
+
+  table(
+    payments.map((p: any) => ({
+      id: p.id.slice(0, 12) + '…',
+      amount: '$' + (p.amount / 100).toFixed(2),
+      status: p.status,
+      rail: p.rail || 'card',
+      memo: (p.memo || '').slice(0, 25),
+      date: p.createdAt?.slice(0, 10),
+    })),
+  );
+}
+
+export async function cmdWebhooks(args: string[], brand: Brand): Promise<void> {
+  const [sub, ...rest] = args;
+  if (!sub || sub === 'help' || sub === '--help') {
+    return cmdWebhooksHelp(brand);
+  }
+  const { flags, positional } = parseFlags(rest);
+  const client = getClient(brand);
+  const $ = brand.cmd;
+
+  switch (sub) {
+    case 'list':
+    case 'ls': {
+      const result = await client.webhooks.list();
+      const webhooks = Array.isArray(result) ? result : (result as any).data ?? [];
+      table(
+        webhooks.map((w: any) => ({
+          id: w.id.slice(0, 12) + '…',
+          url: w.url.slice(0, 40),
+          events: (w.events || []).join(', ').slice(0, 30),
+          status: w.status || 'active',
+        })),
+      );
+      break;
+    }
+
+    case 'create': {
+      const url = flags['url'] || positional[0];
+      if (!url) error(`Usage: ${$} webhooks create --url <url> --events <evt1,evt2>`);
+      const events = (flags['events'] || 'payment.succeeded,payment.failed').split(',');
+      const result = await client.webhooks.register({ url, events });
+      success('Webhook created');
+      console.log(`\n  ${bold('Secret:')} ${(result as any).secret}`);
+      console.log(dim('  Store this — it won\'t be shown again.\n'));
+      json(result);
+      break;
+    }
+
+    case 'delete':
+    case 'rm': {
+      const id = flags['id'] || positional[0];
+      if (!id) error(`Usage: ${$} webhooks delete <id>`);
+      await client.webhooks.delete(id);
+      success(`Webhook ${id} deleted`);
+      break;
+    }
+
+    default:
+      cmdWebhooksHelp(brand);
+  }
+}
+
+function cmdWebhooksHelp(brand: Brand): void {
+  const $ = brand.cmd;
+  console.log(`
+${bold(`${$} webhooks`)} — Manage webhook endpoints
+
+  ${cyan(`${$} webhooks list`)}            List webhooks
+  ${cyan(`${$} webhooks create`)}          Register new webhook
+  ${cyan(`${$} webhooks delete <id>`)}     Delete webhook
+`);
+}
+
+export async function cmdStatus(brand: Brand): Promise<void> {
+  const config = loadConfig(brand);
+
+  console.log(`\n${bold(`${brand.cmd} status`)}\n`);
+
+  const key = config.apiKey || config.accessToken;
+  if (config.email) {
+    console.log(`  ${bold('Logged in:')}  ${config.email}`);
+  }
+  if (key) {
+    const masked = key.slice(0, 12) + '…' + key.slice(-4);
+    console.log(`  ${bold('Auth:')}       ${masked}`);
+  } else {
+    console.log(`  ${bold('Auth:')}       ${dim(`not configured — run: ${brand.authHint}`)}`);
+  }
+  console.log(`  ${bold('Environment:')} ${config.environment || 'sandbox'}`);
+  if (config.baseUrl) console.log(`  ${bold('Base URL:')}    ${config.baseUrl}`);
+  console.log(`  ${bold('Config:')}      ${configFile(brand)}`);
+
+  if (key) {
+    try {
+      const client = getClient(brand);
+      await client.transactions.list({ limit: 1 });
+      console.log(`  ${bold('API:')}         \x1b[32mconnected\x1b[0m`);
+    } catch (e: any) {
+      if (e.statusCode === 401) {
+        console.log(`  ${bold('API:')}         \x1b[31minvalid / expired\x1b[0m`);
+      } else {
+        console.log(`  ${bold('API:')}         \x1b[33munreachable\x1b[0m ${dim(e.message || '')}`);
+      }
+    }
+  }
+
+  console.log();
+}
+
+export function getVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+    return pkg.version;
+  } catch {
+    return '0.1.0';
+  }
+}