arispay 0.1.0

package/src/cli.ts

@@ -0,0 +1,439 @@
+/**
+ * ArisPay CLI — Traditional API key auth
+ *
+ * npm install arispay
+ * arispay init  →  paste API key
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { ArisPay, type ArisPayClient } from './index.js';
+import {
+  type Brand,
+  createBrand,
+  configFile,
+  loadConfig,
+  saveConfig,
+  parseFlags,
+  prompt,
+  promptSecret,
+  error,
+  success,
+  dim,
+  bold,
+  cyan,
+  table,
+  getVersion,
+  cmdAgents,
+  cmdUsers,
+  cmdPay,
+  cmdPaymentGet,
+  cmdTransactions,
+  cmdWebhooks,
+  cmdStatus,
+} from './cli-shared.js';
+
+const BRAND: Brand = createBrand('arispay', 'arispay init');
+
+// ── Init (paste API key) ────────────────────────────────────────────
+
+async function cmdInit(args: string[]): Promise<void> {
+  const { flags } = parseFlags(args);
+  const file = configFile(BRAND);
+
+  console.log(`\n${bold('ArisPay CLI Setup')}\n`);
+  console.log(`  ${dim('Get your API key from the ArisPay dashboard:')}`);
+  console.log(`  ${dim('→ Dashboard → API Keys → Create Key')}\n`);
+
+  const existing = existsSync(file) ? JSON.parse(readFileSync(file, 'utf-8')) : {};
+
+  const apiKey =
+    flags['api-key'] ||
+    (await promptSecret(`  API key${existing.apiKey ? ` ${dim(`[${existing.apiKey.slice(0, 12)}...]`)}` : ''}: `));
+
+  if (!apiKey && !existing.apiKey) error('API key is required');
+
+  console.log(`\n  ${dim('Choose your environment:')}`);
+  console.log(`  ${dim('  sandbox    — Test payments, no real money (recommended to start)')}`);
+  console.log(`  ${dim('  production — Live payments via Fiserv')}\n`);
+
+  const envChoice =
+    flags['env'] ||
+    (await prompt(`  Environment ${dim(`[${existing.environment || 'sandbox'}]`)}: `));
+
+  const baseUrl = flags['base-url'] || undefined;
+
+  const config = {
+    apiKey: apiKey || existing.apiKey,
+    environment: (envChoice || existing.environment || 'sandbox') as 'sandbox' | 'production',
+    ...(baseUrl ? { baseUrl } : {}),
+  };
+
+  saveConfig(BRAND, config);
+
+  try {
+    const client = ArisPay.init({
+      apiKey: config.apiKey!,
+      environment: config.environment,
+      baseUrl: config.baseUrl,
+    });
+    await (client as any).transactions?.list?.({ limit: 1 }).catch(() => {});
+    console.log();
+    success('Connected to ArisPay API');
+  } catch {
+    console.log();
+    console.log(`  ${dim('Could not connect — check your API key and try again.')}`);
+  }
+
+  await postInitMenu(config);
+}
+
+// ── Interactive menu after init ──────────────────────────────────────
+
+async function postInitMenu(config: { apiKey?: string; environment?: string; baseUrl?: string }): Promise<void> {
+  const client = ArisPay.init({
+    apiKey: config.apiKey!,
+    environment: config.environment as any,
+    baseUrl: config.baseUrl,
+  });
+
+  while (true) {
+    console.log(`\n${bold('Get started')}\n`);
+    console.log(`  ${cyan('[1]')} Connect your agent to ArisPay`);
+    console.log(`  ${cyan('[2]')} Add a payment method`);
+    console.log(`  ${cyan('[3]')} Make a test payment`);
+    console.log(`  ${cyan('[4]')} View transactions`);
+    console.log(`  ${cyan('[q]')} Quit\n`);
+
+    const choice = await prompt('  Enter choice: ');
+
+    switch (choice) {
+      case '1':
+        await wizardConnectAgent(client);
+        break;
+      case '2':
+        await wizardAddPaymentMethod(client);
+        break;
+      case '3':
+        await wizardTestPayment(client);
+        break;
+      case '4':
+        await wizardTransactions(client);
+        break;
+      case 'q':
+      case 'quit':
+      case 'exit':
+        console.log(`\n  ${dim('Run')} ${bold('arispay --help')} ${dim('to see all commands.')}\n`);
+        return;
+      default:
+        console.log(`  ${dim('Enter 1, 2, 3, 4, or q')}`);
+    }
+  }
+}
+
+// ── Wizard: Connect Agent ────────────────────────────────────────────
+
+async function wizardConnectAgent(client: ArisPayClient): Promise<void> {
+  console.log(`\n${bold('Connect your agent to ArisPay')}`);
+  console.log(`  ${dim('Register your existing AI agent so it can send and receive payments.')}`);
+  console.log(`  ${dim('This gives your agent a cryptographic identity on the ArisPay network.')}\n`);
+
+  const name = await prompt(`  What is your agent called? `);
+  if (!name) { console.log(dim('  Cancelled.')); return; }
+
+  console.log(`\n  ${dim('How does your agent make payments?')}`);
+  console.log(`  ${dim('  platform   — Your app triggers payments on behalf of the agent (default)')}`);
+  console.log(`  ${dim('  autonomous — The agent decides when to pay, within spend limits you set')}\n`);
+
+  const modeInput = await prompt(`  Mode ${dim('[platform]')}: `);
+  const mode = modeInput === 'autonomous' ? 'autonomous' : 'platform';
+
+  console.log(`\n  ${dim('Connecting agent...')}`);
+
+  try {
+    const agent = await client.agents.register({
+      name,
+      mode,
+      permissions: ['browse', 'payment'],
+    });
+    const a = agent as any;
+
+    // Store agent ID so other steps can auto-fill it
+    const config = loadConfig(BRAND);
+    saveConfig(BRAND, { ...config, agentId: a.id } as any);
+
+    console.log();
+    success(`Agent connected!\n`);
+    console.log(`  ${bold('Agent ID:')}  ${a.id}`);
+    console.log(`  ${bold('Name:')}      ${a.name}`);
+    console.log(`  ${bold('Mode:')}      ${a.mode || mode}`);
+    console.log(`  ${bold('Status:')}    ${a.status}\n`);
+  } catch (e: any) {
+    console.log();
+    console.error(`  \x1b[31m✗\x1b[0m ${e.message || 'Failed to connect agent'}`);
+  }
+}
+
+// ── Wizard: Add Payment Method ───────────────────────────────────────
+
+async function wizardAddPaymentMethod(client: ArisPayClient): Promise<void> {
+  console.log(`\n${bold('Add a payment method')}`);
+  console.log(`  ${dim('Before your agent can spend, you need a funding source.')}\n`);
+
+  // Auto-create end user if not already stored in config
+  const config = loadConfig(BRAND);
+  let userId = (config as any).endUserId;
+
+  if (!userId) {
+    const email = await prompt(`  Your email ${dim('(for payment receipts)')}: `);
+
+    console.log(`\n  ${dim('Setting up your account...')}`);
+    try {
+      const user = await client.users.create({
+        externalId: `cli_${Date.now()}`,
+        email: email || undefined,
+      });
+      userId = (user as any).id;
+      // Store in config so they never have to do this again
+      saveConfig(BRAND, { ...config, endUserId: userId } as any);
+      success('Account ready');
+    } catch (e: any) {
+      console.log();
+      console.error(`  \x1b[31m✗\x1b[0m ${e.message || 'Failed to set up account'}`);
+      return;
+    }
+  }
+
+  console.log(`\n  ${dim('How would you like to fund your agent?')}\n`);
+  console.log(`  ${cyan('[1]')} Card ${dim('— Visa, Mastercard')}`);
+  console.log(`  ${cyan('[2]')} Crypto wallet ${dim('— USDC on Ethereum, Base, Polygon, or Solana')}\n`);
+
+  const methodChoice = await prompt(`  Enter choice: `);
+
+  if (methodChoice === '1') {
+    console.log(`\n  ${dim('Starting card setup...')}`);
+    try {
+      const result = await client.users.addPaymentMethod({
+        userId,
+        type: 'card',
+        returnUrl: 'https://app.arispay.app/card-setup/complete',
+      });
+      const r = result as any;
+      console.log();
+      success(`Card setup ready!\n`);
+      console.log(`  ${bold('Open this URL to securely enter your card details:')}\n`);
+      console.log(`    ${cyan(r.setupUrl)}\n`);
+      console.log(`  ${dim('Your card is tokenized — ArisPay never sees or stores the full number.')}\n`);
+    } catch (e: any) {
+      console.log();
+      console.error(`  \x1b[31m✗\x1b[0m ${e.message || 'Failed to start card setup'}`);
+    }
+  } else if (methodChoice === '2') {
+    console.log();
+    const chain = await prompt(`  Chain ${dim('(ethereum, base, polygon, solana)')}: `);
+    if (!chain) { console.log(dim('  Cancelled.')); return; }
+    const address = await prompt(`  Wallet address: `);
+    if (!address) { console.log(dim('  Cancelled.')); return; }
+
+    console.log(`\n  ${dim('Registering wallet...')}`);
+    try {
+      const result = await client.users.addPaymentMethod({
+        userId,
+        type: 'wallet',
+        walletAddress: address,
+        chain: chain as any,
+      });
+      const r = result as any;
+      console.log();
+      success(`Wallet registered!\n`);
+      console.log(`  ${bold('Next step:')} Approve ArisPay to spend USDC from your wallet.\n`);
+      console.log(`  ${bold('Spender:')}  ${r.spenderAddress}`);
+      console.log(`  ${bold('USDC:')}     ${r.usdcContractAddress}`);
+      console.log(`\n  ${dim('Call approve() on the USDC contract with the spender address above.')}\n`);
+    } catch (e: any) {
+      console.log();
+      console.error(`  \x1b[31m✗\x1b[0m ${e.message || 'Failed to register wallet'}`);
+    }
+  } else {
+    console.log(dim('  Cancelled.'));
+  }
+}
+
+// ── Wizard: Test Payment ─────────────────────────────────────────────
+
+async function wizardTestPayment(client: ArisPayClient): Promise<void> {
+  console.log(`\n${bold('Make a test payment')}`);
+  console.log(`  ${dim('Verify your integration works by sending a test payment.')}\n`);
+
+  const config = loadConfig(BRAND);
+  const storedAgentId = (config as any).agentId;
+
+  let agentId: string;
+  if (storedAgentId) {
+    const useStored = await prompt(`  Use agent ${dim(storedAgentId.slice(0, 12) + '...')}? ${dim('(Y/n)')}: `);
+    if (useStored.toLowerCase() === 'n') {
+      agentId = await prompt(`  Agent ID: `);
+      if (!agentId) { console.log(dim('  Cancelled.')); return; }
+    } else {
+      agentId = storedAgentId;
+    }
+  } else {
+    agentId = await prompt(`  Agent ID: `);
+    if (!agentId) { console.log(dim('  Cancelled.')); return; }
+  }
+
+  const amountStr = await prompt(`  Amount in cents ${dim('(e.g. 500 = $5.00)')}: `);
+  const amount = Number(amountStr);
+  if (!amount || isNaN(amount)) { console.log(dim('  Invalid amount. Cancelled.')); return; }
+
+  const memo = await prompt(`  What is this payment for? `);
+  if (!memo) { console.log(dim('  Cancelled.')); return; }
+
+  console.log(`\n  ${dim(`Sending $${(amount / 100).toFixed(2)} test payment...`)}`);
+
+  try {
+    const payment = await client.payments.create({
+      agentId,
+      amount,
+      currency: 'USD',
+      memo,
+      idempotencyKey: `cli_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    } as any);
+    const p = payment as any;
+    console.log();
+    if (p.status === 'succeeded') {
+      success(`Payment successful!\n`);
+    } else {
+      console.log(`  ${bold('Status:')} ${p.status}\n`);
+    }
+    console.log(`  ${bold('Payment ID:')} ${p.id}`);
+    console.log(`  ${bold('Amount:')}     $${(amount / 100).toFixed(2)} USD`);
+    console.log(`  ${bold('Status:')}     ${p.status}`);
+    console.log();
+  } catch (e: any) {
+    console.log();
+    console.error(`  \x1b[31m✗\x1b[0m ${e.message || 'Payment failed'}`);
+  }
+}
+
+// ── Wizard: View Transactions ────────────────────────────────────────
+
+async function wizardTransactions(client: ArisPayClient): Promise<void> {
+  console.log(`\n${bold('Recent Transactions')}\n`);
+
+  try {
+    const result = await client.transactions.list({ limit: 10 });
+    const payments = (result as any).payments ?? (result as any).transactions ?? [];
+
+    if (payments.length === 0) {
+      console.log(`  ${dim('No transactions yet. Connect an agent and make a test payment to get started.')}\n`);
+      return;
+    }
+
+    table(
+      payments.map((p: any) => ({
+        id: p.id.slice(0, 12) + '…',
+        amount: '$' + (p.amount / 100).toFixed(2),
+        status: p.status,
+        memo: (p.memo || '').slice(0, 25),
+        date: p.createdAt?.slice(0, 10),
+      })),
+    );
+    console.log();
+  } catch (e: any) {
+    console.error(`  \x1b[31m✗\x1b[0m ${e.message || 'Failed to fetch transactions'}`);
+  }
+}
+
+// ── Main ────────────────────────────────────────────────────────────
+
+const HELP = `
+${bold('arispay')} — Agentic payment infrastructure CLI
+
+${bold('Usage:')}
+  arispay <command> [options]
+
+${bold('Commands:')}
+  ${cyan('init')}              Configure API key & environment
+  ${cyan('status')}            Show config & connection status
+  ${cyan('agents')}            Manage AI payment agents
+  ${cyan('users')}             Manage end users & payment methods
+  ${cyan('pay')}               Create a payment
+  ${cyan('payment <id>')}      Get payment details
+  ${cyan('transactions')}      List transactions
+  ${cyan('webhooks')}          Manage webhook endpoints
+
+${bold('Examples:')}
+  arispay init
+  arispay agents create --name "BookingBot" --mode autonomous
+  arispay agents list
+  arispay pay --agent <id> --amount 2000 --memo "Dinner for 2"
+  arispay transactions --agent <id> --from 2025-01-01
+
+${bold('Environment:')}
+  ARISPAY_API_KEY       Override API key
+  ARISPAY_ENV           Override environment (sandbox|production)
+  ARISPAY_BASE_URL      Override API base URL
+
+${bold('Config:')} ~/.arispay/config.json
+`;
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const rest = args.slice(1);
+
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    console.log(HELP);
+    return;
+  }
+
+  if (command === '--version' || command === '-v') {
+    console.log(getVersion());
+    return;
+  }
+
+  try {
+    switch (command) {
+      case 'init':
+        await cmdInit(rest);
+        break;
+      case 'status':
+        await cmdStatus(BRAND);
+        break;
+      case 'agents':
+      case 'agent':
+        await cmdAgents(rest, BRAND);
+        break;
+      case 'users':
+      case 'user':
+        await cmdUsers(rest, BRAND);
+        break;
+      case 'pay':
+        await cmdPay(rest, BRAND);
+        break;
+      case 'payment':
+        await cmdPaymentGet(rest, BRAND);
+        break;
+      case 'transactions':
+      case 'txs':
+        await cmdTransactions(rest, BRAND);
+        break;
+      case 'webhooks':
+      case 'webhook':
+        await cmdWebhooks(rest, BRAND);
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.log(HELP);
+        process.exit(1);
+    }
+  } catch (e: any) {
+    if (e.code && e.message && e.statusCode) {
+      error(`[${e.code}] ${e.message} (HTTP ${e.statusCode})`);
+    } else {
+      error(e.message || String(e));
+    }
+  }
+}
+
+main();

package/src/client.ts

@@ -0,0 +1,65 @@
+import type { ErrorResponse, ErrorCode } from '@arispay/shared';
+import { ArisPayError, ERROR_CODES } from '@arispay/shared';
+
+const SDK_REQUEST_TIMEOUT_MS = 30_000; // 30 seconds
+
+// Valid error codes for runtime validation
+const VALID_ERROR_CODES = new Set(Object.values(ERROR_CODES));
+
+function toErrorCode(code: unknown): ErrorCode {
+  if (typeof code === 'string' && VALID_ERROR_CODES.has(code as ErrorCode)) {
+    return code as ErrorCode;
+  }
+  return 'INTERNAL_ERROR' as ErrorCode;
+}
+
+export class HttpClient {
+  constructor(
+    private baseUrl: string,
+    private apiKey: string,
+  ) {}
+
+  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${this.apiKey}`,
+      'Content-Type': 'application/json',
+    };
+
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+      signal: AbortSignal.timeout(SDK_REQUEST_TIMEOUT_MS),
+    });
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      const err = data as ErrorResponse;
+      throw new ArisPayError(
+        toErrorCode(err.error?.code),
+        err.error?.message ?? 'Request failed',
+        res.status,
+      );
+    }
+
+    return data as T;
+  }
+
+  get<T>(path: string): Promise<T> {
+    return this.request<T>('GET', path);
+  }
+
+  post<T>(path: string, body?: unknown): Promise<T> {
+    return this.request<T>('POST', path, body);
+  }
+
+  put<T>(path: string, body?: unknown): Promise<T> {
+    return this.request<T>('PUT', path, body);
+  }
+
+  delete<T>(path: string): Promise<T> {
+    return this.request<T>('DELETE', path);
+  }
+}

package/src/index.ts

@@ -0,0 +1,98 @@
+import { HttpClient } from './client.js';
+import { AgentService } from './agents.js';
+import { UserService } from './users.js';
+import { PaymentService } from './payments.js';
+import { TransactionService } from './transactions.js';
+import { WebhookService } from './webhooks.js';
+
+export { AgentService } from './agents.js';
+export { UserService } from './users.js';
+export { PaymentService } from './payments.js';
+export { TransactionService } from './transactions.js';
+export { WebhookService } from './webhooks.js';
+export {
+  ArisPayError,
+  SpendLimitExceededError,
+  InsufficientFundsError,
+  InsufficientBalanceError,
+  AgentModeMismatchError,
+} from '@arispay/shared';
+
+// Re-export autonomous mode types for convenience
+export type {
+  AgentTopupRequest,
+  AgentTopupResponse,
+  AgentSweepRequest,
+  AgentSweepResponse,
+  AgentEarningRequest,
+  AgentBalanceResponse,
+  LedgerEntryResponse,
+  LedgerHistoryResponse,
+} from '@arispay/shared';
+
+export interface ArisPayConfig {
+  apiKey: string;
+  environment?: 'sandbox' | 'production';
+  baseUrl?: string;
+}
+
+export interface ArisPayClient {
+  agents: AgentService;
+  users: UserService;
+  payments: PaymentService;
+  transactions: TransactionService;
+  webhooks: WebhookService;
+}
+
+export class ArisPay {
+  /**
+   * Initialize the ArisPay SDK.
+   *
+   * @example
+   * ```ts
+   * import ArisPay from 'arispay';
+   *
+   * const arispay = ArisPay.init({
+   *   apiKey: 'ap_test_abc123',
+   *   environment: 'sandbox',
+   * });
+   *
+   * const agent = await arispay.agents.register({
+   *   name: 'TableClaw',
+   *   description: 'AI restaurant booking agent',
+   *   permissions: ['browse', 'payment'],
+   * });
+   *
+   * const user = await arispay.users.create({
+   *   externalId: 'user_123',
+   *   email: 'jane@example.com',
+   * });
+   *
+   * const payment = await arispay.payments.create({
+   *   agentId: agent.id,
+   *   userId: user.id,
+   *   amount: 20000,
+   *   currency: 'USD',
+   *   merchantUrl: 'https://nobu.com',
+   *   memo: 'Table for 2',
+   *   idempotencyKey: 'booking_123',
+   * });
+   * ```
+   */
+  static init(config: ArisPayConfig): ArisPayClient {
+    const defaultUrl =
+      config.environment === 'production' ? 'https://api.arispay.app' : 'https://api-production-79ea.up.railway.app';
+    const baseUrl = config.baseUrl || defaultUrl;
+    const client = new HttpClient(baseUrl, config.apiKey);
+
+    return {
+      agents: new AgentService(client),
+      users: new UserService(client),
+      payments: new PaymentService(client),
+      transactions: new TransactionService(client),
+      webhooks: new WebhookService(client),
+    };
+  }
+}
+
+export default ArisPay;

package/src/payments.ts

@@ -0,0 +1,22 @@
+import type { CreatePaymentRequest, PaymentResponse, Complete3dsRequest } from '@arispay/shared';
+import type { HttpClient } from './client.js';
+
+export class PaymentService {
+  constructor(private client: HttpClient) {}
+
+  async create(params: CreatePaymentRequest): Promise<PaymentResponse> {
+    return this.client.post<PaymentResponse>('/v1/payments', params);
+  }
+
+  async get(paymentId: string): Promise<PaymentResponse> {
+    return this.client.get<PaymentResponse>(`/v1/payments/${paymentId}`);
+  }
+
+  /** Complete a 3D Secure authentication step (method or challenge) */
+  async complete3ds(paymentId: string, params: Complete3dsRequest): Promise<PaymentResponse> {
+    return this.client.post<PaymentResponse>(
+      `/v1/payments/${paymentId}/3ds/complete`,
+      params,
+    );
+  }
+}

package/src/transactions.ts

@@ -0,0 +1,19 @@
+import type { ListTransactionsQuery, TransactionListResponse } from '@arispay/shared';
+import type { HttpClient } from './client.js';
+
+export class TransactionService {
+  constructor(private client: HttpClient) {}
+
+  async list(params?: ListTransactionsQuery): Promise<TransactionListResponse> {
+    const searchParams = new URLSearchParams();
+    if (params?.userId) searchParams.set('userId', params.userId);
+    if (params?.agentId) searchParams.set('agentId', params.agentId);
+    if (params?.from) searchParams.set('from', params.from);
+    if (params?.to) searchParams.set('to', params.to);
+    if (params?.limit) searchParams.set('limit', String(params.limit));
+    if (params?.offset) searchParams.set('offset', String(params.offset));
+
+    const qs = searchParams.toString();
+    return this.client.get<TransactionListResponse>(`/v1/transactions${qs ? `?${qs}` : ''}`);
+  }
+}