@paylobster/cli 4.3.0 → 4.5.0

package/src/commands/quickstart.ts

@@ -0,0 +1,150 @@
+import { Command } from 'commander';
+import { getAgentInfo, registerAgent } from '../lib/contracts';
+import { getWalletAddress } from '../lib/wallet';
+import { error, success } from '../lib/display';
+import chalk from 'chalk';
+import ora from 'ora';
+import readline from 'readline';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+function prompt(question: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export function createQuickstartCommand(): Command {
+  const cmd = new Command('quickstart')
+    .description('🚀 Interactive wizard to get started with PayLobster')
+    .action(async () => {
+      console.log(chalk.cyan.bold('\n🦞 PayLobster Quickstart Wizard\n'));
+      console.log(chalk.gray('Let\'s get you set up with PayLobster in just a few steps.\n'));
+
+      try {
+        // Step 1: Check wallet configuration
+        console.log(chalk.cyan('Step 1/5:'), chalk.bold('Wallet Configuration'));
+        
+        let address: `0x${string}`;
+        try {
+          address = getWalletAddress() as `0x${string}`;
+        } catch (err) {
+          console.log(chalk.yellow('⚠️  No wallet configured yet.'));
+          console.log('Please run:', chalk.green('plob auth setup'));
+          console.log('Then come back and run', chalk.green('plob quickstart'), 'again.\n');
+          return;
+        }
+        console.log(chalk.green('✓'), 'Wallet configured:', chalk.gray(address));
+
+        // Check if already registered
+        const spinner = ora('Checking registration status...').start();
+        const agentInfo = await getAgentInfo(address);
+        spinner.stop();
+
+        if (agentInfo.registered) {
+          console.log(chalk.green('✓'), 'Already registered as:', chalk.bold(agentInfo.name));
+          console.log(chalk.yellow('\nYou\'re all set! Run'), chalk.green('plob whoami'), chalk.yellow('to see your profile.\n'));
+          return;
+        }
+
+        console.log(chalk.gray('Not registered yet. Let\'s continue...\n'));
+
+        // Step 2: Register agent identity
+        console.log(chalk.cyan('Step 2/5:'), chalk.bold('Agent Identity'));
+        
+        const name = await prompt(chalk.white('Agent name: '));
+        if (!name) {
+          console.log(chalk.red('Name is required. Exiting.\n'));
+          return;
+        }
+
+        const capabilities = await prompt(chalk.white('Capabilities (comma-separated, e.g., "code review, testing, docs"): '));
+        if (!capabilities) {
+          console.log(chalk.red('Capabilities are required. Exiting.\n'));
+          return;
+        }
+
+        spinner.start('Registering agent identity...');
+        try {
+          const tokenId = await registerAgent(name, capabilities);
+          spinner.succeed(chalk.green('✓ Agent registered! Token ID: ') + chalk.bold(tokenId.toString()));
+        } catch (err: any) {
+          spinner.fail(chalk.red('Failed to register agent'));
+          error(`Registration error: ${err.message}`);
+          return;
+        }
+
+        // Step 3: Create treasury
+        console.log(chalk.cyan('\nStep 3/5:'), chalk.bold('Treasury Setup'));
+        console.log(chalk.gray('A treasury manages your funds with budgets and spending rules.'));
+        
+        const createTreasury = await prompt(chalk.white('Create a treasury? (y/n): '));
+        
+        if (createTreasury.toLowerCase() === 'y') {
+          const treasuryName = await prompt(chalk.white('Treasury name: ')) || `${name} Treasury`;
+          
+          spinner.start('Creating treasury...');
+          try {
+            await execAsync(`plob treasury create --name "${treasuryName}"`);
+            spinner.succeed(chalk.green('✓ Treasury created: ') + chalk.bold(treasuryName));
+          } catch (err: any) {
+            spinner.fail(chalk.red('Failed to create treasury'));
+            console.log(chalk.yellow('You can create one later with:'), chalk.green('plob treasury create'));
+          }
+
+          // Step 4: Set default budget
+          console.log(chalk.cyan('\nStep 4/5:'), chalk.bold('Budget Allocation'));
+          console.log(chalk.gray('Recommended: 40% operations, 30% growth, 20% reserve, 10% rewards'));
+          
+          const setBudget = await prompt(chalk.white('Use default budget allocation? (y/n): '));
+          
+          if (setBudget.toLowerCase() === 'y') {
+            spinner.start('Setting budget...');
+            try {
+              await execAsync('plob treasury budget --operations 40 --growth 30 --reserve 20 --rewards 10');
+              spinner.succeed(chalk.green('✓ Budget configured'));
+            } catch (err: any) {
+              spinner.fail(chalk.red('Failed to set budget'));
+              console.log(chalk.yellow('You can set it later with:'), chalk.green('plob treasury budget'));
+            }
+          }
+        } else {
+          console.log(chalk.gray('Skipped treasury setup.'));
+        }
+
+        // Step 5: Summary
+        console.log(chalk.cyan('\nStep 5/5:'), chalk.bold('Summary'));
+        console.log(chalk.green.bold('\n🎉 You\'re all set!\n'));
+        
+        console.log(chalk.bold('What you created:'));
+        console.log(chalk.green('  ✓'), 'Agent identity:', chalk.bold(name));
+        console.log(chalk.green('  ✓'), 'Capabilities:', chalk.gray(capabilities));
+        if (createTreasury.toLowerCase() === 'y') {
+          console.log(chalk.green('  ✓'), 'Treasury with budget allocation');
+        }
+
+        console.log(chalk.bold('\nNext steps:'));
+        console.log(chalk.cyan('  •'), 'View your profile:', chalk.green('plob whoami'));
+        console.log(chalk.cyan('  •'), 'Check system health:', chalk.green('plob health'));
+        console.log(chalk.cyan('  •'), 'Open dashboard:', chalk.green('plob dashboard'));
+        console.log(chalk.cyan('  •'), 'Make your first payment:', chalk.green('plob pay <address> <amount>'));
+        console.log();
+
+      } catch (err: any) {
+        error(`Quickstart failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/search.ts

@@ -0,0 +1,151 @@
+import { Command } from 'commander';
+import { getPublicClient, getContracts, getAgentInfo, getReputation } from '../lib/contracts';
+import { loadConfig } from '../lib/config';
+import { error, outputJSON } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+import chalk from 'chalk';
+import ora from 'ora';
+import type { Address } from 'viem';
+
+interface AgentSearchResult {
+  address: Address;
+  name: string;
+  capabilities: string;
+  reputationScore: number;
+  tokenId: string;
+}
+
+// ABI for AgentRegistered event
+const AGENT_REGISTERED_EVENT = {
+  anonymous: false,
+  inputs: [
+    { indexed: true, name: 'agent', type: 'address' },
+    { indexed: true, name: 'tokenId', type: 'uint256' },
+    { indexed: false, name: 'name', type: 'string' },
+    { indexed: false, name: 'capabilities', type: 'string' },
+  ],
+  name: 'AgentRegistered',
+  type: 'event',
+} as const;
+
+export function createSearchCommand(): Command {
+  const cmd = new Command('search')
+    .description('🔍 Search for agents by name or capability')
+    .argument('<query>', 'Search query (name or capability)')
+    .option('--json', 'Output as JSON')
+    .option('--limit <number>', 'Maximum number of results', '10')
+    .action(async (query: string, options: OutputOptions & { limit?: string }) => {
+      const spinner = ora('Searching for agents...').start();
+
+      try {
+        const config = loadConfig();
+        const client = getPublicClient(config.network);
+        const contracts = getContracts(config.network);
+        const limit = parseInt(options.limit || '10');
+
+        // Get AgentRegistered events
+        // Note: This will scan the entire chain history which may be slow
+        // In production, you'd want to use a subgraph or indexer
+        const logs = await client.getLogs({
+          address: contracts.IDENTITY,
+          event: AGENT_REGISTERED_EVENT,
+          fromBlock: 'earliest',
+          toBlock: 'latest',
+        });
+
+        spinner.text = 'Processing results...';
+
+        // Filter by query (case-insensitive)
+        const queryLower = query.toLowerCase();
+        const matchingLogs = logs.filter((log) => {
+          const name = (log.args.name || '').toLowerCase();
+          const capabilities = (log.args.capabilities || '').toLowerCase();
+          return name.includes(queryLower) || capabilities.includes(queryLower);
+        });
+
+        // Limit results
+        const limitedLogs = matchingLogs.slice(0, limit);
+
+        // Fetch reputation for each agent
+        const results: AgentSearchResult[] = await Promise.all(
+          limitedLogs.map(async (log) => {
+            const address = log.args.agent!;
+            const reputation = await getReputation(address);
+            
+            return {
+              address,
+              name: log.args.name || 'Unknown',
+              capabilities: log.args.capabilities || 'None',
+              reputationScore: Number(reputation.score),
+              tokenId: log.args.tokenId?.toString() || '0',
+            };
+          })
+        );
+
+        spinner.stop();
+
+        // JSON output
+        if (outputJSON({
+          query,
+          results,
+          total: matchingLogs.length,
+          showing: results.length,
+        }, options)) {
+          return;
+        }
+
+        // Pretty output
+        console.log('\n' + chalk.cyan.bold('═══════════════════════════════════════════════════════════'));
+        console.log(chalk.cyan.bold('                   🔍 Agent Search'));
+        console.log(chalk.cyan.bold('═══════════════════════════════════════════════════════════\n'));
+
+        console.log(chalk.gray('  Query:     '), chalk.white(query));
+        console.log(chalk.gray('  Results:   '), chalk.white(`${results.length} / ${matchingLogs.length}`));
+        console.log();
+
+        if (results.length === 0) {
+          console.log(chalk.yellow('  No agents found matching your query.'));
+          console.log();
+          return;
+        }
+
+        // Display results
+        for (let i = 0; i < results.length; i++) {
+          const agent = results[i];
+          
+          let reputationColor = chalk.red;
+          if (agent.reputationScore >= 80) reputationColor = chalk.green;
+          else if (agent.reputationScore >= 50) reputationColor = chalk.yellow;
+
+          console.log(chalk.bold(`  ${i + 1}. ${agent.name}`), chalk.gray(`(#${agent.tokenId})`));
+          console.log(chalk.gray('     Address:      '), chalk.dim(agent.address));
+          console.log(chalk.gray('     Reputation:   '), reputationColor(agent.reputationScore.toString()));
+          console.log(chalk.gray('     Capabilities: '), chalk.white(agent.capabilities));
+          console.log();
+        }
+
+        if (matchingLogs.length > results.length) {
+          console.log(chalk.gray(`  ... and ${matchingLogs.length - results.length} more results`));
+          console.log(chalk.gray('  Use --limit to see more'));
+          console.log();
+        }
+
+        console.log(chalk.cyan.bold('═══════════════════════════════════════════════════════════\n'));
+
+      } catch (err: any) {
+        spinner.stop();
+        error(`Search failed: ${err.message}`);
+        
+        // Provide helpful error message for common issues
+        if (err.message.includes('block range')) {
+          console.log(chalk.yellow('\n⚠️  The search requires scanning many blocks.'));
+          console.log(chalk.gray('This may be slow or hit rate limits with public RPCs.'));
+          console.log(chalk.gray('Consider using a dedicated RPC endpoint or subgraph.\n'));
+        }
+        
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/treasury.ts

@@ -176,6 +176,52 @@ const TREASURY_ABI = [
     ],
     stateMutability: 'view',
   },
+  {
+    type: 'function',
+    name: 'revokeRole',
+    inputs: [{ name: 'account', type: 'address' }],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    name: 'setReserveLock',
+    inputs: [{ name: 'newLockBps', type: 'uint256' }],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    name: 'approveSpender',
+    inputs: [
+      { name: 'token', type: 'address' },
+      { name: 'spender', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    name: 'setIntegration',
+    inputs: [
+      { name: 'integrationName', type: 'string' },
+      { name: 'addr', type: 'address' },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    name: 'withdrawETH',
+    inputs: [
+      { name: 'to', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+      { name: 'reason', type: 'string' },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
 ] as const;
 
 const ERC20_ABI = [
@@ -903,5 +949,344 @@ export function createTreasuryCommand(): Command {
       }
     });
 
+  // Revoke role
+  cmd
+    .command('revoke')
+    .description('Revoke role from an address')
+    .requiredOption('--address <addr>', 'Address to revoke role from')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      address: string;
+    } & OutputOptions) => {
+      try {
+        const accountAddress = options.address as Address;
+        const treasuryAddress = await getTreasuryAddress();
+        const { client, account } = await loadWallet();
+        const publicClient = getPublicClient('mainnet');
+
+        const hash = await withSpinner(
+          'Revoking role...',
+          async () =>
+            client.writeContract({
+              address: treasuryAddress,
+              abi: TREASURY_ABI,
+              functionName: 'revokeRole',
+              args: [accountAddress],
+              account,
+              chain: base,
+            })
+        );
+
+        await publicClient.waitForTransactionReceipt({ hash });
+
+        if (outputJSON({
+          address: accountAddress,
+          transactionHash: hash,
+        }, options)) {
+          return;
+        }
+
+        console.log();
+        success('Role revoked successfully!');
+        console.log();
+        console.log('   Address: ', chalk.gray(accountAddress));
+        console.log('   Tx Hash: ', chalk.gray(hash));
+        console.log();
+      } catch (err) {
+        error(`Failed to revoke role: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Set reserve lock
+  cmd
+    .command('reserve')
+    .description('Set reserve lock percentage (0-5000 bps)')
+    .requiredOption('--lock <bps>', 'Reserve lock in basis points (0-5000)')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      lock: string;
+    } & OutputOptions) => {
+      try {
+        const lockBps = BigInt(options.lock);
+        if (lockBps < 0n || lockBps > 5000n) {
+          throw new Error('Reserve lock must be between 0 and 5000 bps (0-50%)');
+        }
+
+        const treasuryAddress = await getTreasuryAddress();
+        const { client, account } = await loadWallet();
+        const publicClient = getPublicClient('mainnet');
+
+        const hash = await withSpinner(
+          'Setting reserve lock...',
+          async () =>
+            client.writeContract({
+              address: treasuryAddress,
+              abi: TREASURY_ABI,
+              functionName: 'setReserveLock',
+              args: [lockBps],
+              account,
+              chain: base,
+            })
+        );
+
+        await publicClient.waitForTransactionReceipt({ hash });
+
+        if (outputJSON({
+          lockBps: Number(lockBps),
+          lockPercent: Number(lockBps) / 100,
+          transactionHash: hash,
+        }, options)) {
+          return;
+        }
+
+        console.log();
+        success('Reserve lock set successfully!');
+        console.log();
+        console.log('   Lock:    ', chalk.white.bold(`${Number(lockBps) / 100}%`));
+        console.log('   Tx Hash: ', chalk.gray(hash));
+        console.log();
+      } catch (err) {
+        error(`Failed to set reserve lock: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Approve spender
+  cmd
+    .command('approve')
+    .description('Approve token spender')
+    .requiredOption('--token <addr>', 'Token address')
+    .requiredOption('--spender <addr>', 'Spender address')
+    .requiredOption('--amount <amount>', 'Amount to approve')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      token: string;
+      spender: string;
+      amount: string;
+    } & OutputOptions) => {
+      try {
+        const tokenAddress = options.token as Address;
+        const spenderAddress = options.spender as Address;
+        const treasuryAddress = await getTreasuryAddress();
+        const { client, account } = await loadWallet();
+        const publicClient = getPublicClient('mainnet');
+
+        // Get token decimals
+        const decimals = await publicClient.readContract({
+          address: tokenAddress,
+          abi: ERC20_ABI,
+          functionName: 'decimals',
+        });
+
+        const amount = parseUnits(options.amount, decimals);
+
+        const hash = await withSpinner(
+          'Approving spender...',
+          async () =>
+            client.writeContract({
+              address: treasuryAddress,
+              abi: TREASURY_ABI,
+              functionName: 'approveSpender',
+              args: [tokenAddress, spenderAddress, amount],
+              account,
+              chain: base,
+            })
+        );
+
+        await publicClient.waitForTransactionReceipt({ hash });
+
+        if (outputJSON({
+          token: tokenAddress,
+          spender: spenderAddress,
+          amount: options.amount,
+          transactionHash: hash,
+        }, options)) {
+          return;
+        }
+
+        console.log();
+        success('Spender approved successfully!');
+        console.log();
+        console.log('   Token:   ', chalk.gray(tokenAddress));
+        console.log('   Spender: ', chalk.gray(spenderAddress));
+        console.log('   Amount:  ', chalk.white.bold(options.amount));
+        console.log('   Tx Hash: ', chalk.gray(hash));
+        console.log();
+      } catch (err) {
+        error(`Failed to approve spender: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Set integration
+  cmd
+    .command('integrate')
+    .description('Set integration contract')
+    .requiredOption('--name <name>', 'Integration name (spendingMandate|policyRegistry|crossRailLedger)')
+    .requiredOption('--address <addr>', 'Integration contract address')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      name: string;
+      address: string;
+    } & OutputOptions) => {
+      try {
+        const validNames = ['spendingMandate', 'policyRegistry', 'crossRailLedger'];
+        if (!validNames.includes(options.name)) {
+          throw new Error(`Invalid integration name. Must be one of: ${validNames.join(', ')}`);
+        }
+
+        const integrationAddress = options.address as Address;
+        const treasuryAddress = await getTreasuryAddress();
+        const { client, account } = await loadWallet();
+        const publicClient = getPublicClient('mainnet');
+
+        const hash = await withSpinner(
+          'Setting integration...',
+          async () =>
+            client.writeContract({
+              address: treasuryAddress,
+              abi: TREASURY_ABI,
+              functionName: 'setIntegration',
+              args: [options.name, integrationAddress],
+              account,
+              chain: base,
+            })
+        );
+
+        await publicClient.waitForTransactionReceipt({ hash });
+
+        if (outputJSON({
+          name: options.name,
+          address: integrationAddress,
+          transactionHash: hash,
+        }, options)) {
+          return;
+        }
+
+        console.log();
+        success('Integration set successfully!');
+        console.log();
+        console.log('   Name:    ', chalk.white.bold(options.name));
+        console.log('   Address: ', chalk.gray(integrationAddress));
+        console.log('   Tx Hash: ', chalk.gray(hash));
+        console.log();
+      } catch (err) {
+        error(`Failed to set integration: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Withdraw ETH
+  cmd
+    .command('withdraw-eth')
+    .description('Withdraw ETH from treasury')
+    .requiredOption('--to <addr>', 'Recipient address')
+    .requiredOption('--amount <amount>', 'Amount in ETH')
+    .requiredOption('--reason <string>', 'Withdrawal reason')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      to: string;
+      amount: string;
+      reason: string;
+    } & OutputOptions) => {
+      try {
+        const toAddress = options.to as Address;
+        const treasuryAddress = await getTreasuryAddress();
+        const { client, account } = await loadWallet();
+        const publicClient = getPublicClient('mainnet');
+
+        const amount = parseUnits(options.amount, 18);
+
+        const hash = await withSpinner(
+          'Withdrawing ETH...',
+          async () =>
+            client.writeContract({
+              address: treasuryAddress,
+              abi: TREASURY_ABI,
+              functionName: 'withdrawETH',
+              args: [toAddress, amount, options.reason],
+              account,
+              chain: base,
+            })
+        );
+
+        await publicClient.waitForTransactionReceipt({ hash });
+
+        if (outputJSON({
+          to: toAddress,
+          amount: options.amount,
+          reason: options.reason,
+          transactionHash: hash,
+        }, options)) {
+          return;
+        }
+
+        console.log();
+        success('ETH withdrawn successfully!');
+        console.log();
+        console.log('   Amount:  ', chalk.white.bold(`${options.amount} ETH`));
+        console.log('   To:      ', chalk.gray(toAddress));
+        console.log('   Reason:  ', chalk.white(options.reason));
+        console.log('   Tx Hash: ', chalk.gray(hash));
+        console.log();
+      } catch (err) {
+        error(`Failed to withdraw ETH: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Get spend limits
+  cmd
+    .command('limits')
+    .description('View spend limits for an operator')
+    .requiredOption('--address <addr>', 'Operator address')
+    .option('--json', 'Output as JSON')
+    .action(async (address: string, options: OutputOptions & { address: string }) => {
+      try {
+        const operatorAddress = options.address as Address;
+        const treasuryAddress = await getTreasuryAddress();
+        const publicClient = getPublicClient('mainnet');
+
+        const limits = await withSpinner(
+          'Fetching spend limits...',
+          async () =>
+            publicClient.readContract({
+              address: treasuryAddress,
+              abi: TREASURY_ABI,
+              functionName: 'spendLimits',
+              args: [operatorAddress],
+            })
+        );
+
+        const [maxPerTx, maxPerDay, spentToday, dayStart] = limits;
+
+        if (outputJSON({
+          operator: operatorAddress,
+          maxPerTx: formatUnits(maxPerTx, 6),
+          maxPerDay: formatUnits(maxPerDay, 6),
+          spentToday: formatUnits(spentToday, 6),
+          dayStart: Number(dayStart),
+          remainingToday: formatUnits(maxPerDay - spentToday, 6),
+        }, options)) {
+          return;
+        }
+
+        console.log();
+        console.log(chalk.bold.cyan('💳 Spend Limits'));
+        console.log();
+        console.log('   Operator:         ', chalk.gray(operatorAddress));
+        console.log('   Max Per Tx:       ', chalk.white.bold(`$${formatUnits(maxPerTx, 6)}`));
+        console.log('   Max Per Day:      ', chalk.white.bold(`$${formatUnits(maxPerDay, 6)}`));
+        console.log('   Spent Today:      ', chalk.yellow(`$${formatUnits(spentToday, 6)}`));
+        console.log('   Remaining Today:  ', chalk.green(`$${formatUnits(maxPerDay - spentToday, 6)}`));
+        console.log('   Day Start:        ', chalk.gray(new Date(Number(dayStart) * 1000).toLocaleString()));
+        console.log();
+      } catch (err) {
+        error(`Failed to get spend limits: ${err}`);
+        process.exit(1);
+      }
+    });
+
   return cmd;
 }