arispay 0.1.0

package/src/agents.ts

@@ -0,0 +1,117 @@
+import type {
+  RegisterAgentRequest,
+  AgentResponse,
+  AgentListResponse,
+  RotateKeysResponse,
+  SetCircuitBreakerRequest,
+  CircuitBreakerResponse,
+  AgentTopupRequest,
+  AgentTopupResponse,
+  AgentSweepRequest,
+  AgentSweepResponse,
+  AgentEarningRequest,
+  AgentBalanceResponse,
+  LedgerHistoryResponse,
+} from '@arispay/shared';
+import type { HttpClient } from './client.js';
+
+export interface ChildAgentSummary {
+  id: string;
+  name: string;
+  status: string;
+  permissions: string[];
+  delegatedBudget: number | null;
+  delegatedBudgetDay: number | null;
+  delegatedBudgetMo: number | null;
+  createdAt: string;
+}
+
+export class AgentService {
+  constructor(private client: HttpClient) {}
+
+  async register(params: RegisterAgentRequest): Promise<AgentResponse> {
+    return this.client.post<AgentResponse>('/v1/agents', params);
+  }
+
+  async get(agentId: string): Promise<AgentResponse> {
+    return this.client.get<AgentResponse>(`/v1/agents/${agentId}`);
+  }
+
+  async list(params?: { name?: string; status?: string; limit?: number; offset?: number }): Promise<AgentListResponse> {
+    const query = new URLSearchParams();
+    if (params?.name) query.set('name', params.name);
+    if (params?.status) query.set('status', params.status);
+    if (params?.limit) query.set('limit', String(params.limit));
+    if (params?.offset) query.set('offset', String(params.offset));
+    const qs = query.toString();
+    return this.client.get<AgentListResponse>(`/v1/agents${qs ? `?${qs}` : ''}`);
+  }
+
+  async listChildren(agentId: string): Promise<ChildAgentSummary[]> {
+    return this.client.get<ChildAgentSummary[]>(`/v1/agents/${agentId}/children`);
+  }
+
+  async resume(agentId: string): Promise<{ status: string; resumedAt: string }> {
+    return this.client.post<{ status: string; resumedAt: string }>(`/v1/agents/${agentId}/resume`);
+  }
+
+  async setCircuitBreaker(agentId: string, params: SetCircuitBreakerRequest): Promise<CircuitBreakerResponse> {
+    return this.client.put<CircuitBreakerResponse>(`/v1/agents/${agentId}/circuit-breaker`, params);
+  }
+
+  async getCircuitBreaker(agentId: string): Promise<CircuitBreakerResponse> {
+    return this.client.get<CircuitBreakerResponse>(`/v1/agents/${agentId}/circuit-breaker`);
+  }
+
+  async rotateKeys(agentId: string): Promise<RotateKeysResponse> {
+    return this.client.post<RotateKeysResponse>(`/v1/agents/${agentId}/rotate-keys`);
+  }
+
+  // ── Autonomous Agent Methods ──────────────────────────
+
+  /**
+   * Get the current balance for an autonomous agent.
+   */
+  async getBalance(agentId: string): Promise<AgentBalanceResponse> {
+    return this.client.get<AgentBalanceResponse>(`/v1/agents/${agentId}/balance`);
+  }
+
+  /**
+   * Fund an autonomous agent's balance (topup).
+   */
+  async topup(agentId: string, params: AgentTopupRequest): Promise<AgentTopupResponse> {
+    return this.client.post<AgentTopupResponse>(`/v1/agents/${agentId}/topup`, params);
+  }
+
+  /**
+   * Withdraw from an autonomous agent's balance (sweep).
+   * Omit `amount` to sweep everything above the sweep threshold.
+   */
+  async sweep(agentId: string, params?: AgentSweepRequest): Promise<AgentSweepResponse> {
+    return this.client.post<AgentSweepResponse>(`/v1/agents/${agentId}/sweep`, params ?? {});
+  }
+
+  /**
+   * Get paginated ledger history for an autonomous agent.
+   */
+  async getLedger(
+    agentId: string,
+    params?: { limit?: number; offset?: number; type?: string; from?: string; to?: string },
+  ): Promise<LedgerHistoryResponse> {
+    const query = new URLSearchParams();
+    if (params?.limit) query.set('limit', String(params.limit));
+    if (params?.offset) query.set('offset', String(params.offset));
+    if (params?.type) query.set('type', params.type);
+    if (params?.from) query.set('from', params.from);
+    if (params?.to) query.set('to', params.to);
+    const qs = query.toString();
+    return this.client.get<LedgerHistoryResponse>(`/v1/agents/${agentId}/ledger${qs ? `?${qs}` : ''}`);
+  }
+
+  /**
+   * Record an earning (inbound money) for an autonomous agent.
+   */
+  async recordEarning(agentId: string, params: AgentEarningRequest): Promise<AgentTopupResponse> {
+    return this.client.post<AgentTopupResponse>(`/v1/agents/${agentId}/earn`, params);
+  }
+}

package/src/cli-b.ts

@@ -0,0 +1,373 @@
+/**
+ * PayAgent CLI — Device authorization flow
+ *
+ * npm install payagent
+ * payagent login  →  shows code, developer confirms on any browser
+ *
+ * No localhost server. Works in VMs, containers, SSH, WSL.
+ */
+
+import { randomBytes } from 'node:crypto';
+import {
+  type Brand,
+  type Config,
+  createBrand,
+  configFile,
+  loadConfig,
+  saveConfig,
+  parseFlags,
+  error,
+  success,
+  dim,
+  bold,
+  cyan,
+  getVersion,
+  cmdAgents,
+  cmdUsers,
+  cmdPay,
+  cmdPaymentGet,
+  cmdTransactions,
+  cmdWebhooks,
+  cmdStatus,
+} from './cli-shared.js';
+
+const BRAND: Brand = createBrand('payagent', 'payagent login');
+
+// ── Dashboard URLs ──────────────────────────────────────────────────
+
+function getApiUrl(config: Config): string {
+  if (config.baseUrl) return config.baseUrl;
+  return config.environment === 'production'
+    ? 'https://api.arispay.app'
+    : 'https://sandbox.api.arispay.app';
+}
+
+function getDeviceUrl(config: Config): string {
+  if (config.baseUrl) {
+    return config.baseUrl.replace('://api.', '://app.').replace('://sandbox.api.', '://app.');
+  }
+  return config.environment === 'production'
+    ? 'https://app.arispay.app'
+    : 'https://app.sandbox.arispay.app';
+}
+
+// ── Device flow helpers ─────────────────────────────────────────────
+
+function generateUserCode(): string {
+  // 8-char alphanumeric, formatted as XXXX-XXXX for readability
+  const chars = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'; // no 0/O/1/I ambiguity
+  let code = '';
+  const bytes = randomBytes(8);
+  for (let i = 0; i < 8; i++) {
+    code += chars[bytes[i] % chars.length];
+  }
+  return `${code.slice(0, 4)}-${code.slice(4)}`;
+}
+
+interface DeviceCodeResponse {
+  deviceCode: string;
+  userCode: string;
+  verificationUrl: string;
+  expiresIn: number;
+  interval: number;
+}
+
+interface TokenResponse {
+  accessToken: string;
+  refreshToken?: string;
+  expiresAt?: number;
+  email?: string;
+  environment?: string;
+}
+
+async function requestDeviceCode(apiUrl: string): Promise<DeviceCodeResponse> {
+  const res = await fetch(`${apiUrl}/v1/auth/device/code`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ clientId: 'payagent-cli' }),
+    signal: AbortSignal.timeout(15_000),
+  });
+
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error((body as any).error?.message || `Device code request failed (HTTP ${res.status})`);
+  }
+
+  return res.json() as Promise<DeviceCodeResponse>;
+}
+
+async function pollForToken(
+  apiUrl: string,
+  deviceCode: string,
+  intervalSec: number,
+  expiresIn: number,
+): Promise<TokenResponse> {
+  const deadline = Date.now() + expiresIn * 1000;
+
+  while (Date.now() < deadline) {
+    await sleep(intervalSec * 1000);
+
+    const res = await fetch(`${apiUrl}/v1/auth/device/token`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ deviceCode, clientId: 'payagent-cli' }),
+      signal: AbortSignal.timeout(15_000),
+    });
+
+    const body = await res.json() as any;
+
+    if (res.ok && body.accessToken) {
+      return body as TokenResponse;
+    }
+
+    // Standard device flow responses
+    const errorCode = body.error?.code || body.error;
+    if (errorCode === 'authorization_pending') {
+      continue; // keep polling
+    } else if (errorCode === 'slow_down') {
+      intervalSec = Math.min(intervalSec + 1, 10); // back off
+      continue;
+    } else if (errorCode === 'expired_token') {
+      throw new Error('Login expired. Run `payagent login` to try again.');
+    } else if (errorCode === 'access_denied') {
+      throw new Error('Login was denied.');
+    } else {
+      throw new Error(body.error?.message || `Token request failed (HTTP ${res.status})`);
+    }
+  }
+
+  throw new Error('Login timed out. Run `payagent login` to try again.');
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ── Login (device flow) ─────────────────────────────────────────────
+
+async function cmdLogin(args: string[]): Promise<void> {
+  const { flags } = parseFlags(args);
+  const config = loadConfig(BRAND);
+
+  // CI escape hatch: payagent login --api-key <key>
+  if (flags['api-key']) {
+    saveConfig(BRAND, {
+      ...config,
+      apiKey: flags['api-key'],
+      environment: (flags['env'] as Config['environment']) || config.environment,
+    });
+    success('API key saved');
+    return;
+  }
+
+  const apiUrl = getApiUrl(config);
+  const dashboardUrl = getDeviceUrl(config);
+
+  console.log(`\n${bold('PayAgent Login')}\n`);
+
+  // Step 1: Request device code from API
+  let device: DeviceCodeResponse;
+  try {
+    device = await requestDeviceCode(apiUrl);
+  } catch (e: any) {
+    error(e.message || 'Could not initiate login');
+  }
+
+  const verificationUrl = device!.verificationUrl || `${dashboardUrl}/device`;
+
+  // Step 2: Show code to developer
+  console.log(`  Open this URL on any device:\n`);
+  console.log(`    ${cyan(verificationUrl)}\n`);
+  console.log(`  Then enter this code:\n`);
+  console.log(`    ${bold(device!.userCode)}\n`);
+
+  // Step 3: Poll for token
+  const spinner = startSpinner('  Waiting for confirmation');
+
+  try {
+    const token = await pollForToken(
+      apiUrl,
+      device!.deviceCode,
+      device!.interval || 5,
+      device!.expiresIn || 300,
+    );
+    spinner.stop();
+
+    // Save credentials
+    saveConfig(BRAND, {
+      ...config,
+      accessToken: token.accessToken,
+      refreshToken: token.refreshToken,
+      expiresAt: token.expiresAt,
+      email: token.email,
+      environment: (token.environment as Config['environment']) || config.environment,
+    });
+
+    console.log();
+    success(`Logged in as ${bold(token.email || 'developer')}`);
+    if (token.environment) {
+      console.log(`  ${bold('Environment:')} ${token.environment}`);
+    }
+    console.log(`  ${bold('Config:')}      ${dim(configFile(BRAND))}`);
+    console.log();
+  } catch (e: any) {
+    spinner.stop();
+    console.log();
+    error(e.message || 'Authentication failed');
+  }
+}
+
+// ── Logout ──────────────────────────────────────────────────────────
+
+async function cmdLogout(): Promise<void> {
+  const config = loadConfig(BRAND);
+
+  if (!config.accessToken && !config.apiKey && !config.email) {
+    console.log(dim('\n  Not logged in.\n'));
+    return;
+  }
+
+  // Clear auth fields, keep environment/baseUrl preferences
+  saveConfig(BRAND, {
+    environment: config.environment,
+    baseUrl: config.baseUrl,
+  });
+
+  success('Logged out');
+  console.log(`  ${dim('Cleared credentials from')} ${configFile(BRAND)}\n`);
+}
+
+// ── Spinner ─────────────────────────────────────────────────────────
+
+function startSpinner(message: string): { stop: () => void } {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  const interval = setInterval(() => {
+    process.stdout.write(`\r${frames[i++ % frames.length]} ${message}`);
+  }, 80);
+
+  return {
+    stop() {
+      clearInterval(interval);
+      process.stdout.write('\r' + ' '.repeat(message.length + 4) + '\r');
+    },
+  };
+}
+
+// ── Whoami ──────────────────────────────────────────────────────────
+
+async function cmdWhoami(): Promise<void> {
+  const config = loadConfig(BRAND);
+  if (config.email) {
+    console.log(config.email);
+  } else if (config.apiKey || config.accessToken) {
+    const key = (config.apiKey || config.accessToken)!;
+    console.log(`api-key: ${key.slice(0, 12)}…${key.slice(-4)}`);
+  } else {
+    error('Not logged in. Run: payagent login');
+  }
+}
+
+// ── Main ────────────────────────────────────────────────────────────
+
+const HELP = `
+${bold('payagent')} — Agentic payment infrastructure CLI
+
+${bold('Usage:')}
+  payagent <command> [options]
+
+${bold('Auth:')}
+  ${cyan('login')}             Authenticate via device code
+  ${cyan('logout')}            Clear stored credentials
+  ${cyan('whoami')}            Show current identity
+
+${bold('Commands:')}
+  ${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:')}
+  payagent login
+  payagent agents create --name "BookingBot" --mode autonomous
+  payagent agents list
+  payagent pay --agent <id> --amount 2000 --memo "Dinner for 2"
+  payagent transactions --agent <id> --from 2025-01-01
+
+${bold('Environment:')}
+  PAYAGENT_API_KEY      Override auth (CI/scripting)
+  PAYAGENT_ENV          Override environment (sandbox|production)
+  PAYAGENT_BASE_URL     Override API base URL
+
+${bold('Config:')} ~/.payagent/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 'login':
+        await cmdLogin(rest);
+        break;
+      case 'logout':
+        await cmdLogout();
+        break;
+      case 'whoami':
+        await cmdWhoami();
+        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();