@paylobster/cli 4.0.0

package/src/commands/status.ts

@@ -0,0 +1,91 @@
+import { Command } from 'commander';
+import { getAgentInfo, getReputation, getCreditStatus, getBalance, getUserEscrowCount, formatUSDC, formatETH } from '../lib/contracts';
+import { getWalletAddress } from '../lib/wallet';
+import { loadConfig } from '../lib/config';
+import { error, outputJSON, printAgentHeader, formatBoolean, formatNumber, printReputation, formatNetwork } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+export function createStatusCommand(): Command {
+  const cmd = new Command('status')
+    .description('Show agent status and balances')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      try {
+        const address = getWalletAddress() as `0x${string}`;
+        const config = loadConfig();
+
+        // Fetch all data in parallel
+        const [agentInfo, reputation, creditStatus, balance, escrowCount] = await Promise.all([
+          getAgentInfo(address),
+          getReputation(address),
+          getCreditStatus(address),
+          getBalance(address),
+          getUserEscrowCount(address),
+        ]);
+
+        // Calculate reputation score (0-100)
+        const reputationScore = Number(reputation.score);
+        
+        // Format balances
+        const usdcBalance = formatUSDC(balance.usdc);
+        const ethBalance = formatETH(balance.eth);
+        
+        // Format credit
+        const creditLimit = formatUSDC(creditStatus.limit);
+        const creditAvailable = formatUSDC(creditStatus.available);
+        const creditInUse = formatUSDC(creditStatus.inUse);
+
+        if (outputJSON({
+          name: agentInfo.name,
+          address,
+          network: config.network,
+          registered: agentInfo.registered,
+          tokenId: agentInfo.tokenId.toString(),
+          balance: {
+            usdc: usdcBalance,
+            eth: ethBalance,
+          },
+          credit: {
+            limit: creditLimit,
+            available: creditAvailable,
+            inUse: creditInUse,
+          },
+          reputation: reputationScore,
+          escrows: escrowCount,
+        }, options)) {
+          return;
+        }
+
+        // Pretty output
+        printAgentHeader(agentInfo.name || 'Not Registered', address);
+        
+        console.log('Network:     ', formatNetwork(config.network));
+        console.log('Registered:  ', formatBoolean(agentInfo.registered));
+        
+        if (agentInfo.registered) {
+          console.log('Agent ID:    ', agentInfo.tokenId.toString());
+        }
+        
+        console.log();
+        console.log('💰 Balances');
+        console.log('   USDC:     ', formatNumber(usdcBalance), 'USDC');
+        console.log('   ETH:      ', formatNumber(ethBalance), 'ETH');
+        
+        console.log();
+        console.log('💳 Credit');
+        console.log('   Limit:    ', formatNumber(creditLimit), 'USDC');
+        console.log('   Available:', formatNumber(creditAvailable), 'USDC');
+        console.log('   In Use:   ', formatNumber(creditInUse), 'USDC');
+        
+        console.log();
+        console.log('⭐ Reputation:', printReputation(reputationScore));
+        console.log('📦 Escrows:   ', escrowCount, 'total');
+        console.log();
+      } catch (err) {
+        error(`Failed to fetch status: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/index.ts

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { createAuthCommand } from './commands/auth';
+import { createConfigCommand } from './commands/config';
+import { createRegisterCommand } from './commands/register';
+import { createStatusCommand } from './commands/status';
+import { createEscrowCommand } from './commands/escrow';
+import { createMandateCommand } from './commands/mandate';
+import { createPayCommand } from './commands/pay';
+import { createReputationCommand } from './commands/reputation';
+import chalk from 'chalk';
+
+// Load environment variables from .env file if present
+import dotenv from 'dotenv';
+dotenv.config();
+
+const program = new Command();
+
+program
+  .name('plob')
+  .description('🦞 PayLobster CLI - Payment infrastructure for AI agents')
+  .version('4.0.0');
+
+// ASCII art banner
+const banner = `
+${chalk.cyan('┌─────────────────────────────────┐')}
+${chalk.cyan('│')}  ${chalk.bold.cyan('🦞 PayLobster CLI')}              ${chalk.cyan('│')}
+${chalk.cyan('│')}  Payment infrastructure for AI  ${chalk.cyan('│')}
+${chalk.cyan('└─────────────────────────────────┘')}
+`;
+
+// Show banner on help
+program.on('--help', () => {
+  console.log(banner);
+});
+
+// Add commands
+program.addCommand(createAuthCommand());
+program.addCommand(createConfigCommand());
+program.addCommand(createRegisterCommand());
+program.addCommand(createStatusCommand());
+program.addCommand(createEscrowCommand());
+program.addCommand(createMandateCommand());
+program.addCommand(createPayCommand());
+program.addCommand(createReputationCommand());
+
+// Handle errors
+program.exitOverride((err) => {
+  if (err.code === 'commander.help') {
+    console.log(banner);
+  }
+  process.exit(err.exitCode);
+});
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  console.log(banner);
+  program.outputHelp();
+}

package/src/lib/config.ts

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import type { CLIConfig, Network } from './types';
+
+const CONFIG_DIR = path.join(os.homedir(), '.plob');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+// Default configuration
+const DEFAULT_CONFIG: CLIConfig = {
+  network: 'sepolia',
+  indexerUrl: 'https://api.thegraph.com/subgraphs/name/paylobster/registry',
+};
+
+/**
+ * Load CLI configuration from ~/.plob/config.json
+ */
+export function loadConfig(): CLIConfig {
+  try {
+    if (!fs.existsSync(CONFIG_FILE)) {
+      return DEFAULT_CONFIG;
+    }
+    const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    return { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+  } catch (error) {
+    return DEFAULT_CONFIG;
+  }
+}
+
+/**
+ * Save CLI configuration to ~/.plob/config.json
+ */
+export function saveConfig(config: Partial<CLIConfig>): void {
+  try {
+    // Ensure config directory exists
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+
+    const currentConfig = loadConfig();
+    const newConfig = { ...currentConfig, ...config };
+    
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(newConfig, null, 2));
+  } catch (error) {
+    throw new Error(`Failed to save config: ${error}`);
+  }
+}
+
+/**
+ * Get a specific config value
+ */
+export function getConfigValue(key: keyof CLIConfig): any {
+  const config = loadConfig();
+  return config[key];
+}
+
+/**
+ * Set a specific config value
+ */
+export function setConfigValue(key: keyof CLIConfig, value: any): void {
+  const config = loadConfig();
+  (config as any)[key] = value;
+  saveConfig(config);
+}
+
+/**
+ * Get RPC URL for the configured network
+ */
+export function getRpcUrl(network?: Network): string {
+  const config = loadConfig();
+  const net = network || config.network;
+
+  if (config.rpcUrl) {
+    return config.rpcUrl;
+  }
+
+  // Default public RPCs
+  return net === 'mainnet'
+    ? 'https://mainnet.base.org'
+    : 'https://sepolia.base.org';
+}
+
+/**
+ * Clear all configuration
+ */
+export function clearConfig(): void {
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.unlinkSync(CONFIG_FILE);
+  }
+}

package/src/lib/contracts.ts

@@ -0,0 +1,392 @@
+import { createPublicClient, http, type Address, formatUnits, parseUnits } from 'viem';
+import { base, baseSepolia } from 'viem/chains';
+import { loadWallet } from './wallet';
+import { loadConfig, getRpcUrl } from './config';
+import type { Network, AgentInfo, Reputation, CreditStatus, EscrowInfo, Balance } from './types';
+
+// Contract addresses
+const CONTRACTS_MAINNET = {
+  IDENTITY: '0xA174ee274F870631B3c330a85EBCad74120BE662' as Address,
+  REPUTATION: '0x02bb4132a86134684976E2a52E43D59D89E64b29' as Address,
+  CREDIT: '0xD9241Ce8a721Ef5fcCAc5A11983addC526eC80E1' as Address,
+  ESCROW: '0x49EdEe04c78B7FeD5248A20706c7a6c540748806' as Address,
+  USDC: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' as Address,
+};
+
+const CONTRACTS_SEPOLIA = {
+  IDENTITY: '0x3dfA02Ed4F0e4F10E8031d7a4cB8Ea0bBbFbCB8c' as Address,
+  // NOTE: Reputation address provided has 41 hex chars (invalid). Using placeholder.
+  // Original (invalid): 0xb0033901e3b94f4F36dA0b3e396942C1e78205C7d
+  REPUTATION: '0x0000000000000000000000000000000000000000' as Address, // TODO: Fix this address
+  CREDIT: '0xBA64e2b2F2a80D03A4B13b3396942C1e78205C7d' as Address,
+  ESCROW: '0x78D1f50a1965dE34f6b5a3D3546C94FE1809Cd82' as Address,
+  USDC: '0x036CbD53842c5426634e7929541eC2318f3dCF7e' as Address,
+};
+
+// ABIs
+const IDENTITY_ABI = [
+  {
+    inputs: [
+      { name: 'agentURI', type: 'string' },
+      { name: 'name', type: 'string' },
+      { name: 'capabilities', type: 'string' },
+    ],
+    name: 'register',
+    outputs: [{ name: 'agentId', type: 'uint256' }],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [{ name: 'user', type: 'address' }],
+    name: 'getAgentInfo',
+    outputs: [
+      { name: 'name', type: 'string' },
+      { name: 'tokenId', type: 'uint256' },
+      { name: 'registered', type: 'bool' },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const;
+
+const REPUTATION_ABI = [
+  {
+    inputs: [{ name: 'user', type: 'address' }],
+    name: 'getReputation',
+    outputs: [
+      { name: 'score', type: 'uint256' },
+      { name: 'trustVector', type: 'uint256' },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const;
+
+const CREDIT_ABI = [
+  {
+    inputs: [{ name: 'user', type: 'address' }],
+    name: 'getCreditStatus',
+    outputs: [
+      { name: 'limit', type: 'uint256' },
+      { name: 'available', type: 'uint256' },
+      { name: 'inUse', type: 'uint256' },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const;
+
+const ESCROW_ABI = [
+  {
+    inputs: [
+      { name: 'recipient', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+      { name: 'token', type: 'address' },
+      { name: 'description', type: 'string' },
+    ],
+    name: 'createEscrow',
+    outputs: [{ name: 'escrowId', type: 'uint256' }],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [{ name: 'escrowId', type: 'uint256' }],
+    name: 'releaseEscrow',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [{ name: 'escrowId', type: 'uint256' }],
+    name: 'getEscrow',
+    outputs: [
+      { name: 'sender', type: 'address' },
+      { name: 'recipient', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+      { name: 'token', type: 'address' },
+      { name: 'status', type: 'uint8' },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const;
+
+const USDC_ABI = [
+  {
+    inputs: [
+      { name: 'spender', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+    name: 'approve',
+    outputs: [{ name: '', type: 'bool' }],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [{ name: 'account', type: 'address' }],
+    name: 'balanceOf',
+    outputs: [{ name: '', type: 'uint256' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const;
+
+/**
+ * Get contract addresses for network
+ */
+export function getContracts(network: Network) {
+  return network === 'mainnet' ? CONTRACTS_MAINNET : CONTRACTS_SEPOLIA;
+}
+
+/**
+ * Create public client for reading
+ */
+export function getPublicClient(network?: Network) {
+  const config = loadConfig();
+  const net = network || config.network;
+  const chain = net === 'mainnet' ? base : baseSepolia;
+
+  return createPublicClient({
+    chain,
+    transport: http(getRpcUrl(net)),
+  });
+}
+
+/**
+ * Register agent identity
+ */
+export async function registerAgent(name: string, capabilities: string): Promise<bigint> {
+  const { client, account } = await loadWallet();
+  const config = loadConfig();
+  const contracts = getContracts(config.network);
+  const chain = config.network === 'mainnet' ? base : baseSepolia;
+
+  const hash = await client.writeContract({
+    address: contracts.IDENTITY,
+    abi: IDENTITY_ABI,
+    functionName: 'register',
+    args: ['', name, capabilities],
+    account,
+    chain,
+  });
+
+  return BigInt(hash);
+}
+
+/**
+ * Get agent info
+ */
+export async function getAgentInfo(address: Address): Promise<AgentInfo> {
+  const config = loadConfig();
+  const publicClient = getPublicClient(config.network);
+  const contracts = getContracts(config.network);
+
+  const result = await publicClient.readContract({
+    address: contracts.IDENTITY,
+    abi: IDENTITY_ABI,
+    functionName: 'getAgentInfo',
+    args: [address],
+  });
+
+  return {
+    name: result[0],
+    tokenId: result[1],
+    registered: result[2],
+    address,
+  };
+}
+
+/**
+ * Get reputation score
+ */
+export async function getReputation(address: Address): Promise<Reputation> {
+  const config = loadConfig();
+  const publicClient = getPublicClient(config.network);
+  const contracts = getContracts(config.network);
+
+  const result = await publicClient.readContract({
+    address: contracts.REPUTATION,
+    abi: REPUTATION_ABI,
+    functionName: 'getReputation',
+    args: [address],
+  });
+
+  return {
+    score: result[0],
+    trustVector: result[1],
+  };
+}
+
+/**
+ * Get credit status
+ */
+export async function getCreditStatus(address: Address): Promise<CreditStatus> {
+  const config = loadConfig();
+  const publicClient = getPublicClient(config.network);
+  const contracts = getContracts(config.network);
+
+  const result = await publicClient.readContract({
+    address: contracts.CREDIT,
+    abi: CREDIT_ABI,
+    functionName: 'getCreditStatus',
+    args: [address],
+  });
+
+  return {
+    limit: result[0],
+    available: result[1],
+    inUse: result[2],
+  };
+}
+
+/**
+ * Get USDC balance
+ */
+export async function getUSDCBalance(address: Address): Promise<bigint> {
+  const config = loadConfig();
+  const publicClient = getPublicClient(config.network);
+  const contracts = getContracts(config.network);
+
+  const balance = await publicClient.readContract({
+    address: contracts.USDC,
+    abi: USDC_ABI,
+    functionName: 'balanceOf',
+    args: [address],
+  });
+
+  return balance;
+}
+
+/**
+ * Get ETH balance
+ */
+export async function getETHBalance(address: Address): Promise<bigint> {
+  const config = loadConfig();
+  const publicClient = getPublicClient(config.network);
+
+  const balance = await publicClient.getBalance({ address });
+  return balance;
+}
+
+/**
+ * Get full balance info
+ */
+export async function getBalance(address: Address): Promise<Balance> {
+  const [usdc, eth] = await Promise.all([
+    getUSDCBalance(address),
+    getETHBalance(address),
+  ]);
+
+  return { usdc, eth };
+}
+
+/**
+ * Create escrow
+ */
+export async function createEscrow(
+  recipient: Address,
+  amount: string,
+  description: string
+): Promise<bigint> {
+  const { client, account } = await loadWallet();
+  const config = loadConfig();
+  const contracts = getContracts(config.network);
+  const chain = config.network === 'mainnet' ? base : baseSepolia;
+
+  // Parse amount (USDC has 6 decimals)
+  const amountWei = parseUnits(amount, 6);
+
+  // First approve USDC
+  const approveHash = await client.writeContract({
+    address: contracts.USDC,
+    abi: USDC_ABI,
+    functionName: 'approve',
+    args: [contracts.ESCROW, amountWei],
+    account,
+    chain,
+  });
+
+  // Wait for approval
+  const publicClient = getPublicClient(config.network);
+  await publicClient.waitForTransactionReceipt({ hash: approveHash });
+
+  // Create escrow
+  const hash = await client.writeContract({
+    address: contracts.ESCROW,
+    abi: ESCROW_ABI,
+    functionName: 'createEscrow',
+    args: [recipient, amountWei, contracts.USDC, description],
+    account,
+    chain,
+  });
+
+  return BigInt(hash);
+}
+
+/**
+ * Release escrow
+ */
+export async function releaseEscrow(escrowId: bigint): Promise<string> {
+  const { client, account } = await loadWallet();
+  const config = loadConfig();
+  const contracts = getContracts(config.network);
+  const chain = config.network === 'mainnet' ? base : baseSepolia;
+
+  const hash = await client.writeContract({
+    address: contracts.ESCROW,
+    abi: ESCROW_ABI,
+    functionName: 'releaseEscrow',
+    args: [escrowId],
+    account,
+    chain,
+  });
+
+  return hash;
+}
+
+/**
+ * Get escrow details
+ */
+export async function getEscrow(escrowId: bigint): Promise<EscrowInfo> {
+  const config = loadConfig();
+  const publicClient = getPublicClient(config.network);
+  const contracts = getContracts(config.network);
+
+  const result = await publicClient.readContract({
+    address: contracts.ESCROW,
+    abi: ESCROW_ABI,
+    functionName: 'getEscrow',
+    args: [escrowId],
+  });
+
+  return {
+    sender: result[0],
+    recipient: result[1],
+    amount: result[2],
+    token: result[3],
+    status: result[4],
+  };
+}
+
+/**
+ * Get user's escrow count
+ * NOTE: This function is not yet implemented on the deployed contract
+ */
+export async function getUserEscrowCount(address: Address): Promise<number> {
+  // TODO: Implement when Escrow V3 is deployed with getUserTransactionCount
+  return 0;
+}
+
+/**
+ * Format USDC amount for display
+ */
+export function formatUSDC(amount: bigint): string {
+  return formatUnits(amount, 6);
+}
+
+/**
+ * Format ETH amount for display
+ */
+export function formatETH(amount: bigint): string {
+  return formatUnits(amount, 18);
+}