@paylobster/cli 4.0.1 → 4.1.0

package/src/commands/stream.ts

@@ -0,0 +1,244 @@
+import { Command } from 'commander';
+import { success, error, info, withSpinner, outputJSON, formatAddress, confirm, createTable } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+export function createStreamCommand(): Command {
+  const cmd = new Command('stream')
+    .description('Manage payment streams');
+
+  // plob stream create
+  cmd
+    .command('create')
+    .description('Create a new payment stream')
+    .requiredOption('--to <address>', 'Recipient address')
+    .requiredOption('--amount <amount>', 'Total amount in USDC')
+    .requiredOption('--duration <duration>', 'Duration (e.g., 30d, 1h, 60m)')
+    .option('--interval <interval>', 'Payment interval (e.g., 1d, 1h)', '1d')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      to: string;
+      amount: string;
+      duration: string;
+      interval: string;
+    } & OutputOptions) => {
+      try {
+        // Validate address
+        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 stream: ${options.amount} USDC over ${options.duration}`);
+        info(`To: ${formatAddress(options.to)}`);
+        info(`Interval: ${options.interval}`);
+
+        // TODO: Implement actual stream creation
+        const streamId = Math.floor(Math.random() * 1000000); // Placeholder
+
+        const txHash = await withSpinner(
+          'Creating payment stream...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          streamId,
+          txHash,
+          to: options.to,
+          amount: options.amount,
+          duration: options.duration,
+          interval: options.interval,
+        }, options)) {
+          return;
+        }
+
+        success('Payment stream created!');
+        info(`Stream ID: ${streamId}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to create stream: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob stream cancel
+  cmd
+    .command('cancel')
+    .description('Cancel a payment stream')
+    .argument('<streamId>', 'Stream ID')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (streamId: string, options: { yes?: boolean } & OutputOptions) => {
+      try {
+        if (!options.yes) {
+          const confirmed = await confirm(`Cancel stream ${streamId}?`);
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        const txHash = await withSpinner(
+          'Cancelling stream...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({ streamId, txHash }, options)) {
+          return;
+        }
+
+        success(`Stream ${streamId} cancelled!`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to cancel stream: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob stream list
+  cmd
+    .command('list')
+    .description('List your payment streams')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const streams = [
+          {
+            id: 1,
+            to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+            amount: '1000 USDC',
+            streamed: '300 USDC',
+            remaining: '700 USDC',
+            status: 'active',
+          },
+          {
+            id: 2,
+            to: '0x8626f6940E2eb28930eFb4CeF49B2d1F2C9C1199',
+            amount: '500 USDC',
+            streamed: '500 USDC',
+            remaining: '0 USDC',
+            status: 'completed',
+          },
+        ];
+
+        if (outputJSON(streams, options)) {
+          return;
+        }
+
+        if (streams.length === 0) {
+          info('No streams found');
+          return;
+        }
+
+        const table = createTable({
+          head: ['ID', 'To', 'Amount', 'Streamed', 'Remaining', 'Status'],
+        });
+
+        for (const stream of streams) {
+          table.push([
+            stream.id,
+            formatAddress(stream.to),
+            stream.amount,
+            stream.streamed,
+            stream.remaining,
+            stream.status,
+          ]);
+        }
+
+        console.log(table.toString());
+      } catch (err) {
+        error(`Failed to list streams: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob stream get
+  cmd
+    .command('get')
+    .description('Get stream details')
+    .argument('<streamId>', 'Stream ID')
+    .option('--json', 'Output as JSON')
+    .action(async (streamId: string, options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const stream = {
+          id: streamId,
+          from: '0x1234567890123456789012345678901234567890',
+          to: '0x0987654321098765432109876543210987654321',
+          totalAmount: '1000 USDC',
+          streamedAmount: '300 USDC',
+          remainingAmount: '700 USDC',
+          startTime: new Date().toISOString(),
+          duration: '30 days',
+          interval: '1 day',
+          status: 'active',
+        };
+
+        if (outputJSON(stream, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Stream ID:     ', stream.id);
+        console.log('From:          ', stream.from);
+        console.log('To:            ', stream.to);
+        console.log('Total Amount:  ', stream.totalAmount);
+        console.log('Streamed:      ', stream.streamedAmount);
+        console.log('Remaining:     ', stream.remainingAmount);
+        console.log('Start Time:    ', stream.startTime);
+        console.log('Duration:      ', stream.duration);
+        console.log('Interval:      ', stream.interval);
+        console.log('Status:        ', stream.status);
+        console.log();
+      } catch (err) {
+        error(`Failed to get stream: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob stream withdraw
+  cmd
+    .command('withdraw')
+    .description('Withdraw from a stream')
+    .argument('<streamId>', 'Stream ID')
+    .option('--json', 'Output as JSON')
+    .action(async (streamId: string, options: OutputOptions) => {
+      try {
+        const txHash = await withSpinner(
+          'Withdrawing from stream...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({ streamId, txHash }, options)) {
+          return;
+        }
+
+        success('Withdrawal successful!');
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to withdraw: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/index.ts

@@ -9,6 +9,14 @@ import { createEscrowCommand } from './commands/escrow';
 import { createMandateCommand } from './commands/mandate';
 import { createPayCommand } from './commands/pay';
 import { createReputationCommand } from './commands/reputation';
+import { createStreamCommand } from './commands/stream';
+import { createDisputeCommand } from './commands/dispute';
+import { createCreditScoreCommand } from './commands/credit-score';
+import { createCascadeCommand } from './commands/cascade';
+import { createIntentCommand } from './commands/intent';
+import { createComplianceCommand } from './commands/compliance';
+import { createOracleCommand } from './commands/oracle';
+import { createRevenueShareCommand } from './commands/revenue-share';
 import chalk from 'chalk';
 
 // Load environment variables from .env file if present
@@ -44,6 +52,14 @@ program.addCommand(createEscrowCommand());
 program.addCommand(createMandateCommand());
 program.addCommand(createPayCommand());
 program.addCommand(createReputationCommand());
+program.addCommand(createStreamCommand());
+program.addCommand(createDisputeCommand());
+program.addCommand(createCreditScoreCommand());
+program.addCommand(createCascadeCommand());
+program.addCommand(createIntentCommand());
+program.addCommand(createComplianceCommand());
+program.addCommand(createOracleCommand());
+program.addCommand(createRevenueShareCommand());
 
 // Handle errors
 program.exitOverride((err) => {