@paylobster/cli 4.0.0

package/src/commands/auth.ts

@@ -0,0 +1,75 @@
+import { Command } from 'commander';
+import { saveToKeystore, loadWallet, getWalletAddress } from '../lib/wallet';
+import { saveConfig } from '../lib/config';
+import { success, error, warning, info } from '../lib/display';
+
+export function createAuthCommand(): Command {
+  const cmd = new Command('auth')
+    .description('Set up wallet authentication');
+
+  cmd
+    .option('--private-key <key>', 'Set private key directly')
+    .option('--env <var>', 'Use environment variable (PRIVATE_KEY or custom)')
+    .option('--keystore <file>', 'Save to keystore file')
+    .action(async (options) => {
+      try {
+        if (options.privateKey) {
+          // Validate private key format
+          if (!options.privateKey.startsWith('0x') || options.privateKey.length !== 66) {
+            error('Invalid private key format. Must be 0x-prefixed 64-character hex string');
+            process.exit(1);
+          }
+
+          // Save to keystore
+          const keystorePath = saveToKeystore(options.privateKey, options.keystore || 'default.key');
+          
+          // Update config
+          saveConfig({
+            wallet: {
+              type: 'keystore',
+              path: options.keystore || 'default.key',
+            },
+          });
+
+          success('Wallet configured successfully');
+          info(`Private key saved to keystore: ${keystorePath}`);
+          warning('Keep your keystore file secure!');
+          
+          // Show address
+          const address = getWalletAddress();
+          info(`Wallet address: ${address}`);
+        } else if (options.env) {
+          // Use environment variable
+          saveConfig({
+            wallet: {
+              type: 'env',
+            },
+          });
+
+          success(`Configured to use environment variable: ${options.env}`);
+          info('Set the environment variable before running commands:');
+          console.log(`  export ${options.env}="0x..."`);
+        } else {
+          // Default: check if wallet is already configured
+          try {
+            const address = getWalletAddress();
+            success('Wallet is already configured');
+            info(`Address: ${address}`);
+          } catch (err) {
+            error('No wallet configured');
+            console.log();
+            console.log('Usage:');
+            console.log('  plob auth --private-key 0x...');
+            console.log('  plob auth --env PRIVATE_KEY');
+            console.log();
+            process.exit(1);
+          }
+        }
+      } catch (err) {
+        error(`Failed to configure wallet: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/config.ts

@@ -0,0 +1,84 @@
+import { Command } from 'commander';
+import { loadConfig, saveConfig, clearConfig } from '../lib/config';
+import { success, error, outputJSON, printConfig, formatNetwork } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+export function createConfigCommand(): Command {
+  const cmd = new Command('config')
+    .description('Manage CLI configuration');
+
+  // plob config show
+  cmd
+    .command('show')
+    .description('Show current configuration')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      try {
+        const config = loadConfig();
+
+        if (outputJSON(config, options)) {
+          return;
+        }
+
+        console.log();
+        printConfig({
+          network: formatNetwork(config.network),
+          rpcUrl: config.rpcUrl || 'default',
+          indexerUrl: config.indexerUrl || 'default',
+          wallet: config.wallet?.type || 'env',
+        });
+        console.log();
+      } catch (err) {
+        error(`Failed to load config: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob config set <key> <value>
+  cmd
+    .command('set')
+    .description('Set a configuration value')
+    .argument('<key>', 'Configuration key (network, rpcUrl, indexerUrl)')
+    .argument('<value>', 'Configuration value')
+    .action(async (key: string, value: string) => {
+      try {
+        const validKeys = ['network', 'rpcUrl', 'indexerUrl'];
+        
+        if (!validKeys.includes(key)) {
+          error(`Invalid config key: ${key}`);
+          console.log(`Valid keys: ${validKeys.join(', ')}`);
+          process.exit(1);
+        }
+
+        if (key === 'network' && !['mainnet', 'sepolia'].includes(value)) {
+          error('Network must be "mainnet" or "sepolia"');
+          process.exit(1);
+        }
+
+        const config = loadConfig();
+        (config as any)[key] = value;
+        saveConfig(config);
+
+        success(`Set ${key} = ${value}`);
+      } catch (err) {
+        error(`Failed to set config: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob config reset
+  cmd
+    .command('reset')
+    .description('Reset configuration to defaults')
+    .action(async () => {
+      try {
+        clearConfig();
+        success('Configuration reset to defaults');
+      } catch (err) {
+        error(`Failed to reset config: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/escrow.ts

@@ -0,0 +1,222 @@
+import { Command } from 'commander';
+import { createEscrow, releaseEscrow, getEscrow, formatUSDC, getUserEscrowCount } from '../lib/contracts';
+import { getWalletAddress } from '../lib/wallet';
+import { success, error, info, withSpinner, outputJSON, formatAddress, formatStatus, printEscrowTable, confirm } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+export function createEscrowCommand(): Command {
+  const cmd = new Command('escrow')
+    .description('Manage escrows');
+
+  // plob escrow create
+  cmd
+    .command('create')
+    .description('Create a new escrow')
+    .requiredOption('--to <address>', 'Recipient address')
+    .requiredOption('--amount <amount>', 'Amount in USDC')
+    .option('--description <desc>', 'Escrow description', 'Payment via PayLobster CLI')
+    .option('--json', 'Output as JSON')
+    .action(async (options: { to: string; amount: string; description: string } & OutputOptions) => {
+      try {
+        // Validate address format
+        if (!options.to.startsWith('0x') || options.to.length !== 42) {
+          error('Invalid recipient address format');
+          process.exit(1);
+        }
+
+        // Validate amount
+        const amount = parseFloat(options.amount);
+        if (isNaN(amount) || amount <= 0) {
+          error('Invalid amount. Must be a positive number');
+          process.exit(1);
+        }
+
+        info(`Creating escrow for ${options.amount} USDC to ${formatAddress(options.to)}`);
+        
+        const txHash = await withSpinner(
+          'Creating escrow (approving USDC + creating escrow)...',
+          async () => {
+            return await createEscrow(
+              options.to as `0x${string}`,
+              options.amount,
+              options.description
+            );
+          }
+        );
+
+        if (outputJSON({ 
+          txHash: txHash.toString(),
+          to: options.to,
+          amount: options.amount,
+          description: options.description,
+        }, options)) {
+          return;
+        }
+
+        success('Escrow created successfully!');
+        info(`Transaction: ${txHash.toString()}`);
+        info(`Recipient: ${options.to}`);
+        info(`Amount: ${options.amount} USDC`);
+      } catch (err) {
+        error(`Failed to create escrow: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob escrow list
+  cmd
+    .command('list')
+    .description('List your escrows')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      try {
+        const address = getWalletAddress() as `0x${string}`;
+        const count = await getUserEscrowCount(address);
+
+        if (count === 0) {
+          info('No escrows found');
+          return;
+        }
+
+        info(`Total escrows: ${count}`);
+        
+        // Fetch details for each escrow
+        // Note: This is a simplified implementation. In production, you'd want pagination
+        // or fetch from an indexer
+        const escrows = [];
+        for (let i = 0; i < Math.min(count, 10); i++) {
+          try {
+            const escrowData = await getEscrow(BigInt(i));
+            escrows.push({
+              id: i,
+              from: escrowData.sender,
+              to: escrowData.recipient,
+              amount: formatUSDC(escrowData.amount) + ' USDC',
+              status: escrowData.status,
+            });
+          } catch (err) {
+            // Skip if can't fetch
+          }
+        }
+
+        if (outputJSON(escrows, options)) {
+          return;
+        }
+
+        printEscrowTable(escrows);
+        
+        if (count > 10) {
+          info(`Showing first 10 of ${count} escrows`);
+        }
+      } catch (err) {
+        error(`Failed to list escrows: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob escrow get
+  cmd
+    .command('get')
+    .description('Get escrow details')
+    .argument('<id>', 'Escrow ID')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: OutputOptions) => {
+      try {
+        const escrowId = BigInt(id);
+        const escrow = await getEscrow(escrowId);
+
+        if (outputJSON({
+          id: id,
+          sender: escrow.sender,
+          recipient: escrow.recipient,
+          amount: formatUSDC(escrow.amount),
+          token: escrow.token,
+          status: escrow.status,
+        }, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Escrow ID:  ', id);
+        console.log('From:       ', escrow.sender);
+        console.log('To:         ', escrow.recipient);
+        console.log('Amount:     ', formatUSDC(escrow.amount), 'USDC');
+        console.log('Token:      ', escrow.token);
+        console.log('Status:     ', formatStatus(escrow.status));
+        console.log();
+      } catch (err) {
+        error(`Failed to get escrow: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob escrow release
+  cmd
+    .command('release')
+    .description('Release an escrow')
+    .argument('<id>', 'Escrow ID')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: { yes?: boolean } & OutputOptions) => {
+      try {
+        const escrowId = BigInt(id);
+        
+        // Get escrow details
+        const escrow = await getEscrow(escrowId);
+
+        // Verify sender
+        const address = getWalletAddress() as `0x${string}`;
+        if (escrow.sender.toLowerCase() !== address.toLowerCase()) {
+          error('You are not the sender of this escrow');
+          process.exit(1);
+        }
+
+        // Check status
+        if (escrow.status !== 1) { // 1 = active
+          error(`Escrow is not active (status: ${formatStatus(escrow.status)})`);
+          process.exit(1);
+        }
+
+        // Confirm
+        if (!options.yes) {
+          console.log();
+          console.log('Escrow details:');
+          console.log('  ID:      ', id);
+          console.log('  To:      ', escrow.recipient);
+          console.log('  Amount:  ', formatUSDC(escrow.amount), 'USDC');
+          console.log();
+
+          const confirmed = await confirm('Release this escrow?');
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        const txHash = await withSpinner(
+          'Releasing escrow...',
+          async () => {
+            return await releaseEscrow(escrowId);
+          }
+        );
+
+        if (outputJSON({ 
+          txHash,
+          escrowId: id,
+          released: formatUSDC(escrow.amount),
+        }, options)) {
+          return;
+        }
+
+        success('Escrow released successfully!');
+        info(`Transaction: ${txHash}`);
+        info(`Released: ${formatUSDC(escrow.amount)} USDC`);
+        info(`Recipient: ${escrow.recipient}`);
+      } catch (err) {
+        error(`Failed to release escrow: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/mandate.ts

@@ -0,0 +1,56 @@
+import { Command } from 'commander';
+import { error, info, warning } from '../lib/display';
+
+/**
+ * Mandate commands
+ * Note: Full mandate implementation requires additional contract functions
+ * This is a placeholder for future implementation
+ */
+export function createMandateCommand(): Command {
+  const cmd = new Command('mandate')
+    .description('Manage payment mandates (coming soon)');
+
+  cmd
+    .command('create')
+    .description('Create a new mandate')
+    .option('--agent <address>', 'Agent address')
+    .option('--limit <amount>', 'Spending limit in USDC')
+    .option('--duration <days>', 'Duration in days')
+    .action(async () => {
+      warning('Mandate creation is not yet implemented');
+      info('This feature will be available in a future update');
+      console.log();
+      console.log('Mandates allow you to delegate spending permissions to agents');
+      console.log('with configurable limits and time restrictions.');
+      console.log();
+    });
+
+  cmd
+    .command('list')
+    .description('List your mandates')
+    .action(async () => {
+      warning('Mandate listing is not yet implemented');
+      info('This feature will be available in a future update');
+    });
+
+  cmd
+    .command('revoke')
+    .description('Revoke a mandate')
+    .argument('<id>', 'Mandate ID')
+    .action(async () => {
+      warning('Mandate revocation is not yet implemented');
+      info('This feature will be available in a future update');
+    });
+
+  cmd
+    .command('adjust')
+    .description('Adjust mandate limits')
+    .argument('<id>', 'Mandate ID')
+    .option('--limit <amount>', 'New spending limit')
+    .action(async () => {
+      warning('Mandate adjustment is not yet implemented');
+      info('This feature will be available in a future update');
+    });
+
+  return cmd;
+}

package/src/commands/pay.ts

@@ -0,0 +1,96 @@
+import { Command } from 'commander';
+import { createEscrow } from '../lib/contracts';
+import { success, error, info, withSpinner, outputJSON, formatAddress, confirm } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+/**
+ * Simple pay command (wrapper around escrow create)
+ */
+export function createPayCommand(): Command {
+  const cmd = new Command('pay')
+    .description('Execute payment (creates escrow)')
+    .requiredOption('--to <address>', 'Recipient address')
+    .requiredOption('--amount <amount>', 'Amount in USDC')
+    .option('--description <desc>', 'Payment description', 'Payment via PayLobster CLI')
+    .option('--mandate <id>', 'Mandate ID (not yet implemented)')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      to: string;
+      amount: string;
+      description: string;
+      mandate?: string;
+      yes?: boolean;
+    } & OutputOptions) => {
+      try {
+        // Validate address format
+        if (!options.to.startsWith('0x') || options.to.length !== 42) {
+          error('Invalid recipient address format');
+          process.exit(1);
+        }
+
+        // Validate amount
+        const amount = parseFloat(options.amount);
+        if (isNaN(amount) || amount <= 0) {
+          error('Invalid amount. Must be a positive number');
+          process.exit(1);
+        }
+
+        if (options.mandate) {
+          error('Mandate payments are not yet implemented');
+          info('Use plob escrow create instead');
+          process.exit(1);
+        }
+
+        // Confirm payment
+        if (!options.yes) {
+          console.log();
+          console.log('Payment details:');
+          console.log('  To:          ', options.to);
+          console.log('  Amount:      ', options.amount, 'USDC');
+          console.log('  Description: ', options.description);
+          console.log();
+
+          const confirmed = await confirm('Send this payment?');
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        info(`Sending ${options.amount} USDC to ${formatAddress(options.to)}`);
+        
+        const txHash = await withSpinner(
+          'Processing payment...',
+          async () => {
+            return await createEscrow(
+              options.to as `0x${string}`,
+              options.amount,
+              options.description
+            );
+          }
+        );
+
+        if (outputJSON({ 
+          txHash: txHash.toString(),
+          to: options.to,
+          amount: options.amount,
+          description: options.description,
+        }, options)) {
+          return;
+        }
+
+        success('Payment sent successfully!');
+        info(`Transaction: ${txHash.toString()}`);
+        info(`Recipient: ${options.to}`);
+        info(`Amount: ${options.amount} USDC`);
+        console.log();
+        info('Note: Payment is held in escrow. Use `plob escrow release <id>` to release funds.');
+      } catch (err) {
+        error(`Failed to send payment: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/register.ts

@@ -0,0 +1,57 @@
+import { Command } from 'commander';
+import { registerAgent, getAgentInfo } from '../lib/contracts';
+import { getWalletAddress } from '../lib/wallet';
+import { success, error, info, withSpinner, outputJSON } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+export function createRegisterCommand(): Command {
+  const cmd = new Command('register')
+    .description('Register agent identity on-chain')
+    .requiredOption('--name <name>', 'Agent name')
+    .requiredOption('--capabilities <capabilities>', 'Comma-separated capabilities (e.g., "code-review,bug-fix")')
+    .option('--json', 'Output as JSON')
+    .action(async (options: { name: string; capabilities: string } & OutputOptions) => {
+      try {
+        // Check if already registered
+        const address = getWalletAddress() as `0x${string}`;
+        const agentInfo = await getAgentInfo(address);
+
+        if (agentInfo.registered) {
+          error('Agent is already registered');
+          info(`Current name: ${agentInfo.name}`);
+          info(`Token ID: ${agentInfo.tokenId.toString()}`);
+          process.exit(1);
+        }
+
+        // Register
+        const txHash = await withSpinner(
+          'Registering agent on-chain...',
+          async () => {
+            return await registerAgent(options.name, options.capabilities);
+          }
+        );
+
+        // Get updated info
+        const updatedInfo = await getAgentInfo(address);
+
+        if (outputJSON({ 
+          txHash: txHash.toString(), 
+          agentId: updatedInfo.tokenId.toString(),
+          name: updatedInfo.name,
+          address,
+        }, options)) {
+          return;
+        }
+
+        success('Agent registered successfully!');
+        info(`Name: ${updatedInfo.name}`);
+        info(`Agent ID: ${updatedInfo.tokenId.toString()}`);
+        info(`Transaction: ${txHash.toString()}`);
+      } catch (err) {
+        error(`Failed to register agent: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/reputation.ts

@@ -0,0 +1,84 @@
+import { Command } from 'commander';
+import { getReputation, getAgentInfo } from '../lib/contracts';
+import { error, outputJSON, printReputation, header } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+export function createReputationCommand(): Command {
+  const cmd = new Command('reputation')
+    .description('Check reputation score')
+    .argument('[address]', 'Address to check (default: your wallet)')
+    .option('--json', 'Output as JSON')
+    .action(async (addressArg: string | undefined, options: OutputOptions) => {
+      try {
+        let address: `0x${string}`;
+
+        if (addressArg) {
+          // Validate address format
+          if (!addressArg.startsWith('0x') || addressArg.length !== 42) {
+            error('Invalid address format');
+            process.exit(1);
+          }
+          address = addressArg as `0x${string}`;
+        } else {
+          // Use wallet address
+          const { getWalletAddress } = await import('../lib/wallet');
+          address = getWalletAddress() as `0x${string}`;
+        }
+
+        // Fetch reputation and agent info
+        const [reputation, agentInfo] = await Promise.all([
+          getReputation(address),
+          getAgentInfo(address),
+        ]);
+
+        const reputationScore = Number(reputation.score);
+        const trustVector = Number(reputation.trustVector);
+
+        if (outputJSON({
+          address,
+          name: agentInfo.name,
+          registered: agentInfo.registered,
+          reputation: {
+            score: reputationScore,
+            trustVector,
+          },
+        }, options)) {
+          return;
+        }
+
+        // Pretty output
+        header('Reputation Report');
+        console.log();
+        console.log('Address:    ', address);
+        
+        if (agentInfo.registered) {
+          console.log('Name:       ', agentInfo.name);
+          console.log('Agent ID:   ', agentInfo.tokenId.toString());
+        } else {
+          console.log('Status:     ', 'Not registered');
+        }
+        
+        console.log();
+        console.log('Reputation: ', printReputation(reputationScore));
+        console.log('Trust:      ', trustVector);
+        console.log();
+
+        // Add interpretation
+        if (reputationScore >= 80) {
+          console.log('✅ Excellent reputation - highly trusted');
+        } else if (reputationScore >= 60) {
+          console.log('⚠️  Good reputation - generally trusted');
+        } else if (reputationScore >= 40) {
+          console.log('⚠️  Fair reputation - proceed with caution');
+        } else {
+          console.log('❌ Low reputation - high risk');
+        }
+        console.log();
+      } catch (err) {
+        error(`Failed to fetch reputation: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}