payment-skill 1.0.0

package/src/commands/bunq.ts

@@ -0,0 +1,223 @@
+/**
+ * Payment Skill - Bunq Commands
+ * 
+ * Bunq API CLI commands
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { BunqClient } from '../api/bunq';
+import { configManager } from '../core/config';
+import { transactionManager } from '../core/transaction';
+
+export const bunqCommands = new Command('bunq')
+  .description('Bunq API operations');
+
+// List accounts
+bunqCommands
+  .command('accounts')
+  .description('List monetary accounts')
+  .requiredOption('-u, --user <id>', 'User ID')
+  .action(async (options) => {
+    const spinner = ora('Fetching accounts...').start();
+    try {
+      const config = configManager.getProvider('bunq');
+      if (!config) {
+        throw new Error('Bunq not configured. Run: payment-skill provider add bunq');
+      }
+      
+      const client = new BunqClient(config as any);
+      const accounts = await client.getMonetaryAccounts(options.user);
+      
+      spinner.stop();
+      console.log(chalk.blue('Monetary Accounts:'));
+      accounts.forEach((acc: any) => {
+        console.log(`  ${acc.id} - ${acc.description} - ${acc.balance.value} ${acc.balance.currency}`);
+      });
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });
+
+// Get balance
+bunqCommands
+  .command('balance')
+  .description('Get account balance')
+  .requiredOption('-u, --user <id>', 'User ID')
+  .requiredOption('-a, --account <id>', 'Account ID')
+  .action(async (options) => {
+    const spinner = ora('Fetching balance...').start();
+    try {
+      const config = configManager.getProvider('bunq');
+      if (!config) {
+        throw new Error('Bunq not configured');
+      }
+      
+      const client = new BunqClient(config as any);
+      const account = await client.getMonetaryAccount(options.user, options.account);
+      
+      spinner.stop();
+      console.log(chalk.blue('Account Balance:'));
+      console.log(`  ${account.balance.value} ${account.balance.currency}`);
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });
+
+// Create payment
+bunqCommands
+  .command('pay')
+  .description('Create a payment')
+  .requiredOption('-u, --user <id>', 'User ID')
+  .requiredOption('-a, --account <id>', 'Account ID')
+  .requiredOption('--amount <amount>', 'Payment amount')
+  .requiredOption('--currency <currency>', 'Currency (e.g., EUR)')
+  .requiredOption('--to-iban <iban>', 'Recipient IBAN')
+  .requiredOption('--to-name <name>', 'Recipient name')
+  .requiredOption('--description <text>', 'Payment description')
+  .action(async (options) => {
+    const spinner = ora('Creating payment...').start();
+    try {
+      const config = configManager.getProvider('bunq');
+      if (!config) {
+        throw new Error('Bunq not configured');
+      }
+      
+      // Create transaction record
+      const tx = transactionManager.createTransaction(
+        'bunq',
+        'bunq-payment',
+        parseFloat(options.amount),
+        options.currency,
+        { toIban: options.toIban, description: options.description }
+      );
+      
+      const client = new BunqClient(config as any);
+      const payment = await client.createPayment(
+        options.user,
+        options.account,
+        options.amount,
+        options.currency,
+        options.toIban,
+        options.toName,
+        options.description
+      );
+      
+      transactionManager.updateTransactionStatus(tx.id, 'completed');
+      
+      spinner.succeed(chalk.green('Payment created'));
+      console.log(`  Transaction ID: ${tx.id}`);
+      console.log(`  Payment ID: ${payment.id}`);
+      console.log(`  Status: ${payment.status}`);
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });
+
+// Create payment request
+bunqCommands
+  .command('request')
+  .description('Create a payment request (RequestInquiry)')
+  .requiredOption('-u, --user <id>', 'User ID')
+  .requiredOption('-a, --account <id>', 'Account ID')
+  .requiredOption('--amount <amount>', 'Request amount')
+  .requiredOption('--currency <currency>', 'Currency')
+  .requiredOption('--to <alias>', 'Counterparty alias (email/phone/IBAN)')
+  .requiredOption('--description <text>', 'Request description')
+  .option('--type <type>', 'Alias type (EMAIL/PHONE/IBAN)', 'EMAIL')
+  .action(async (options) => {
+    const spinner = ora('Creating payment request...').start();
+    try {
+      const config = configManager.getProvider('bunq');
+      if (!config) {
+        throw new Error('Bunq not configured');
+      }
+      
+      const client = new BunqClient(config as any);
+      const request = await client.createRequestInquiry(
+        options.user,
+        options.account,
+        options.amount,
+        options.currency,
+        {
+          type: options.type,
+          value: options.to,
+          name: options.to
+        },
+        options.description
+      );
+      
+      spinner.succeed(chalk.green('Payment request created'));
+      console.log(`  Request ID: ${request.id}`);
+      console.log(`  Status: ${request.status}`);
+      console.log(chalk.yellow('  Waiting for recipient to accept...'));
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });
+
+// List payments
+bunqCommands
+  .command('payments')
+  .description('List payments')
+  .requiredOption('-u, --user <id>', 'User ID')
+  .requiredOption('-a, --account <id>', 'Account ID')
+  .option('-l, --limit <number>', 'Limit results', '10')
+  .action(async (options) => {
+    const spinner = ora('Fetching payments...').start();
+    try {
+      const config = configManager.getProvider('bunq');
+      if (!config) {
+        throw new Error('Bunq not configured');
+      }
+      
+      const client = new BunqClient(config as any);
+      const payments = await client.getPayments(options.user, options.account, parseInt(options.limit));
+      
+      spinner.stop();
+      console.log(chalk.blue(`Payments (${payments.length}):`));
+      payments.forEach((p: any) => {
+        const direction = p.amount.value.startsWith('-') ? 'OUT' : 'IN';
+        const color = direction === 'OUT' ? chalk.red : chalk.green;
+        console.log(`  ${p.id} - ${color(direction)} - ${p.amount.value} ${p.amount.currency} - ${p.description}`);
+      });
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });
+
+// List requests
+bunqCommands
+  .command('requests')
+  .description('List payment requests')
+  .requiredOption('-u, --user <id>', 'User ID')
+  .requiredOption('-a, --account <id>', 'Account ID')
+  .action(async (options) => {
+    const spinner = ora('Fetching requests...').start();
+    try {
+      const config = configManager.getProvider('bunq');
+      if (!config) {
+        throw new Error('Bunq not configured');
+      }
+      
+      const client = new BunqClient(config as any);
+      const requests = await client.getRequestInquiries(options.user, options.account);
+      
+      spinner.stop();
+      console.log(chalk.blue(`Payment Requests (${requests.length}):`));
+      requests.forEach((r: any) => {
+        const statusColor = r.status === 'ACCEPTED' ? chalk.green : 
+                           r.status === 'PENDING' ? chalk.yellow : chalk.red;
+        console.log(`  ${r.id} - ${statusColor(r.status)} - ${r.amount_inquired.value} ${r.amount_inquired.currency}`);
+      });
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });

package/src/commands/config.ts

@@ -0,0 +1,72 @@
+/**
+ * Payment Skill - Config Commands
+ * 
+ * Configuration management CLI commands
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../core/config';
+
+export const configCommands = new Command('config')
+  .description('Manage payment-skill configuration');
+
+configCommands
+  .command('get')
+  .description('Get configuration value')
+  .argument('<key>', 'Configuration key')
+  .action((key) => {
+    const config = configManager.getConfig();
+    const value = config[key];
+    if (value !== undefined) {
+      console.log(JSON.stringify(value, null, 2));
+    } else {
+      console.log(chalk.yellow(`Key '${key}' not found`));
+    }
+  });
+
+configCommands
+  .command('set')
+  .description('Set configuration value')
+  .argument('<key>', 'Configuration key')
+  .argument('<value>', 'Configuration value')
+  .action((key, value) => {
+    try {
+      const parsedValue = JSON.parse(value);
+      configManager.setConfig(key, parsedValue);
+      console.log(chalk.green(`✓ Set ${key} = ${value}`));
+    } catch {
+      configManager.setConfig(key, value);
+      console.log(chalk.green(`✓ Set ${key} = ${value}`));
+    }
+  });
+
+configCommands
+  .command('list')
+  .description('List all configuration')
+  .action(() => {
+    const config = configManager.getConfig();
+    console.log(chalk.blue('Configuration:'));
+    console.log(JSON.stringify(config, null, 2));
+  });
+
+configCommands
+  .command('init')
+  .description('Initialize configuration')
+  .action(() => {
+    console.log(chalk.blue('Initializing payment-skill configuration...'));
+    console.log(chalk.green('✓ Configuration initialized'));
+    console.log(chalk.gray('Use "payment-skill provider add" to configure providers'));
+  });
+
+configCommands
+  .command('path')
+  .description('Show configuration file path')
+  .action(() => {
+    const path = require('path').join(
+      process.env.HOME || process.env.USERPROFILE || '.',
+      '.payment-skill',
+      'config.json'
+    );
+    console.log(path);
+  });

package/src/commands/emergency.ts

@@ -0,0 +1,94 @@
+/**
+ * Payment Skill - Emergency Commands
+ * 
+ * Emergency stop and safety CLI commands
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../core/config';
+import { transactionManager } from '../core/transaction';
+
+export const emergencyCommands = new Command('emergency')
+  .description('Emergency stop and safety controls');
+
+emergencyCommands
+  .command('stop')
+  .description('Activate emergency stop - halt all transactions')
+  .option('-r, --reason <reason>', 'Reason for emergency stop')
+  .action((options) => {
+    const reason = options.reason || 'Manual activation';
+    
+    console.log(chalk.red.bold('🚨 ACTIVATING EMERGENCY STOP'));
+    console.log(chalk.red(`Reason: ${reason}`));
+    
+    // Get pending transactions
+    const pending = transactionManager.getPendingTransactions();
+    console.log(chalk.yellow(`Found ${pending.length} pending transactions`));
+    
+    // Activate emergency stop
+    configManager.activateEmergencyStop(reason);
+    
+    // Cancel all pending
+    const cancelled = transactionManager.cancelAllPending();
+    
+    console.log(chalk.green(`✓ Emergency stop activated`));
+    console.log(chalk.green(`✓ Cancelled ${cancelled} pending transactions`));
+    console.log(chalk.red.bold('\n⚠️  All API operations are now BLOCKED'));
+    console.log(chalk.gray('Use "payment-skill emergency resume" to re-enable'));
+  });
+
+emergencyCommands
+  .command('resume')
+  .description('Deactivate emergency stop - resume operations')
+  .action(() => {
+    if (!configManager.isEmergencyStopActive()) {
+      console.log(chalk.yellow('Emergency stop is not active'));
+      return;
+    }
+    
+    console.log(chalk.blue('Deactivating emergency stop...'));
+    configManager.deactivateEmergencyStop();
+    console.log(chalk.green('✓ Emergency stop deactivated'));
+    console.log(chalk.green('✓ API operations resumed'));
+  });
+
+emergencyCommands
+  .command('status')
+  .description('Check emergency stop status')
+  .action(() => {
+    const state = configManager.getEmergencyStopState();
+    
+    if (state.active) {
+      console.log(chalk.red.bold('🚨 EMERGENCY STOP IS ACTIVE'));
+      console.log(chalk.red(`Activated: ${state.activatedAt}`));
+      console.log(chalk.red(`Reason: ${state.reason}`));
+      console.log(chalk.yellow(`Pending transactions on hold: ${state.pendingTransactions.length}`));
+    } else {
+      console.log(chalk.green('✓ Emergency stop is inactive'));
+      console.log(chalk.gray('All operations normal'));
+    }
+  });
+
+emergencyCommands
+  .command('kill-all')
+  .description('Kill all pending transactions (use with caution)')
+  .option('-f, --force', 'Force without confirmation')
+  .action((options) => {
+    const pending = transactionManager.getPendingTransactions();
+    
+    if (pending.length === 0) {
+      console.log(chalk.yellow('No pending transactions to kill'));
+      return;
+    }
+    
+    console.log(chalk.red.bold(`⚠️  About to kill ${pending.length} pending transactions`));
+    
+    if (!options.force) {
+      console.log(chalk.yellow('Use --force to confirm'));
+      return;
+    }
+    
+    const cancelled = transactionManager.cancelAllPending();
+    console.log(chalk.green(`✓ Killed ${cancelled} transactions`));
+  });

package/src/commands/limits.ts

@@ -0,0 +1,126 @@
+/**
+ * Payment Skill - Limit Commands
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../core/config';
+
+export const limitCommands = new Command('limits')
+  .description('Manage payment limits and controls');
+
+limitCommands
+  .command('get')
+  .description('Get current limits')
+  .action(() => {
+    const limits = configManager.getLimits();
+    console.log(chalk.blue('Current Limits:'));
+    console.log(`  Per Transaction: ${limits.perTransaction}`);
+    console.log(`  Daily: ${limits.daily}`);
+    console.log(`  Weekly: ${limits.weekly}`);
+    console.log(`  Monthly: ${limits.monthly}`);
+    console.log(`  Max per Hour: ${limits.maxTransactionsPerHour}`);
+  });
+
+limitCommands
+  .command('set')
+  .description('Set limits')
+  .option('--per-transaction <amount>', 'Per transaction limit')
+  .option('--daily <amount>', 'Daily limit')
+  .option('--weekly <amount>', 'Weekly limit')
+  .option('--monthly <amount>', 'Monthly limit')
+  .option('--max-per-hour <count>', 'Max transactions per hour')
+  .action((options) => {
+    const limits: any = {};
+    if (options.perTransaction) limits.perTransaction = parseInt(options.perTransaction);
+    if (options.daily) limits.daily = parseInt(options.daily);
+    if (options.weekly) limits.weekly = parseInt(options.weekly);
+    if (options.monthly) limits.monthly = parseInt(options.monthly);
+    if (options.maxPerHour) limits.maxTransactionsPerHour = parseInt(options.maxPerHour);
+    
+    configManager.setLimits(limits);
+    console.log(chalk.green('✓ Limits updated'));
+  });
+
+const timeWindowCommands = new Command('time-window')
+  .description('Time window controls');
+
+timeWindowCommands
+  .command('get')
+  .description('Get time window settings')
+  .action(() => {
+    const tw = configManager.getTimeWindow();
+    console.log(chalk.blue('Time Window:'));
+    console.log(`  Enabled: ${tw.enabled}`);
+    console.log(`  Start: ${tw.start}`);
+    console.log(`  End: ${tw.end}`);
+    console.log(`  Timezone: ${tw.timezone}`);
+  });
+
+timeWindowCommands
+  .command('set')
+  .description('Set time window')
+  .option('--start <time>', 'Start time (HH:MM)')
+  .option('--end <time>', 'End time (HH:MM)')
+  .option('--timezone <tz>', 'Timezone')
+  .action((options) => {
+    const tw: any = {};
+    if (options.start) tw.start = options.start;
+    if (options.end) tw.end = options.end;
+    if (options.timezone) tw.timezone = options.timezone;
+    
+    configManager.setTimeWindow(tw);
+    console.log(chalk.green('✓ Time window updated'));
+  });
+
+timeWindowCommands
+  .command('enable')
+  .description('Enable time window')
+  .action(() => {
+    configManager.setTimeWindow({ enabled: true });
+    console.log(chalk.green('✓ Time window enabled'));
+  });
+
+timeWindowCommands
+  .command('disable')
+  .description('Disable time window')
+  .action(() => {
+    configManager.setTimeWindow({ enabled: false });
+    console.log(chalk.green('✓ Time window disabled'));
+  });
+
+limitCommands.addCommand(timeWindowCommands);
+
+limitCommands
+  .command('block')
+  .description('Block a merchant')
+  .argument('<merchant-id>', 'Merchant ID')
+  .action((merchantId) => {
+    console.log(chalk.yellow(`Merchant blocking not yet implemented for ${merchantId}`));
+  });
+
+limitCommands
+  .command('unblock')
+  .description('Unblock a merchant')
+  .argument('<merchant-id>', 'Merchant ID')
+  .action((merchantId) => {
+    console.log(chalk.yellow(`Merchant unblocking not yet implemented for ${merchantId}`));
+  });
+
+limitCommands
+  .command('block-category')
+  .description('Block a category')
+  .argument('<category>', 'Category name')
+  .action((category) => {
+    configManager.addBlockedCategory(category);
+    console.log(chalk.green(`✓ Category '${category}' blocked`));
+  });
+
+limitCommands
+  .command('unblock-category')
+  .description('Unblock a category')
+  .argument('<category>', 'Category name')
+  .action((category) => {
+    configManager.removeBlockedCategory(category);
+    console.log(chalk.green(`✓ Category '${category}' unblocked`));
+  });

package/src/commands/merchant.ts

@@ -0,0 +1,39 @@
+/**
+ * Payment Skill - Merchant Commands
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+
+export const merchantCommands = new Command('merchant')
+  .description('Merchant detection and management');
+
+merchantCommands
+  .command('detect')
+  .description('Detect merchant API capabilities')
+  .argument('<domain>', 'Merchant domain')
+  .action(async (domain) => {
+    console.log(chalk.blue(`Detecting API capabilities for ${domain}...`));
+    // Implementation would detect actual API
+    console.log(chalk.yellow('Merchant detection not yet implemented'));
+  });
+
+merchantCommands
+  .command('list-apis')
+  .description('List supported merchant APIs')
+  .action(() => {
+    console.log(chalk.blue('Supported Merchant APIs:'));
+    console.log('  - wise.com (Wise Platform)');
+    console.log('  - bunq.com (Bunq API)');
+    console.log('  - stripe.com (Stripe Connect)');
+    console.log('  - airwallex.com (Airwallex API)');
+  });
+
+merchantCommands
+  .command('capabilities')
+  .description('Get merchant capabilities')
+  .argument('<merchant-id>', 'Merchant ID')
+  .action((merchantId) => {
+    console.log(chalk.blue(`Capabilities for ${merchantId}:`));
+    console.log(chalk.yellow('Not yet implemented'));
+  });

package/src/commands/pay.ts

@@ -0,0 +1,109 @@
+/**
+ * Payment Skill - Pay Command
+ * 
+ * Execute payment using templates - HYBRID ARCHITECTURE
+ * OpenClaw selects template and provides parameters
+ * Payment-skill executes the predefined flow
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { templateEngine } from '../core/template-engine';
+
+export const payCommand = new Command('pay')
+  .description('Execute a payment using a template (HYBRID ARCHITECTURE)')
+  .requiredOption('-t, --template <id>', 'Template ID (e.g., wise_standard_transfer, bunq_instant_payment)')
+  .requiredOption('--amount <amount>', 'Payment amount')
+  .requiredOption('--currency <currency>', 'Currency code (EUR, USD, etc.)')
+  .option('--profile-id <id>', 'Wise profile ID')
+  .option('--user-id <id>', 'Bunq user ID')
+  .option('--account-id <id>', 'Bunq account ID')
+  .option('--recipient-id <id>', 'Recipient/account ID')
+  .option('--recipient-iban <iban>', 'Recipient IBAN')
+  .option('--recipient-name <name>', 'Recipient name')
+  .option('--reference <text>', 'Payment reference')
+  .option('--description <text>', 'Payment description')
+  .option('--dry-run', 'Show what would be executed without actually doing it')
+  .action(async (options) => {
+    const spinner = ora('Initializing payment...').start();
+    
+    try {
+      // Get template
+      const template = templateEngine.getTemplate(options.template);
+      if (!template) {
+        spinner.fail(`Template '${options.template}' not found`);
+        console.log(chalk.yellow('\nAvailable templates:'));
+        const templates = templateEngine.getAllTemplates();
+        templates.forEach(t => {
+          console.log(`  ${t.templateId} - ${t.description}`);
+        });
+        process.exit(1);
+      }
+
+      spinner.succeed(`Using template: ${template.templateId}`);
+      console.log(chalk.blue(`Description: ${template.description}`));
+      console.log(chalk.gray(`Merchant: ${template.merchant}`));
+      
+      // Build parameters
+      const params: Record<string, any> = {
+        amount: options.amount,
+        currency: options.currency.toUpperCase()
+      };
+      
+      if (options.profileId) params.profileId = options.profileId;
+      if (options.userId) params.userId = options.userId;
+      if (options.accountId) params.accountId = options.accountId;
+      if (options.recipientId) params.recipientId = options.recipientId;
+      if (options.recipientIban) params.recipientIban = options.recipientIban;
+      if (options.recipientName) params.recipientName = options.recipientName;
+      if (options.reference) params.reference = options.reference;
+      if (options.description) params.description = options.description;
+
+      // Show execution plan
+      console.log(chalk.blue('\nExecution Plan:'));
+      template.steps.sort((a, b) => a.order - b.order).forEach(step => {
+        console.log(`  ${step.order}. ${step.name}`);
+        if (step.async) {
+          console.log(chalk.yellow(`     [ASYNC - ${step.confirmation?.type || 'manual'} confirmation]`));
+        }
+      });
+
+      console.log(chalk.blue('\nParameters:'));
+      Object.entries(params).forEach(([key, value]) => {
+        console.log(`  ${key}: ${value}`);
+      });
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('\n[DRY RUN - No actual payment will be made]'));
+        return;
+      }
+
+      // Confirm execution
+      console.log(chalk.yellow('\n⚠️  This will execute the payment flow above.'));
+      console.log(chalk.gray('Use --dry-run to preview without executing.'));
+
+      // Execute template
+      const execSpinner = ora('Executing payment flow...').start();
+      
+      try {
+        const tx = await templateEngine.executeTemplate(options.template, params);
+        
+        execSpinner.succeed(chalk.green('Payment flow completed!'));
+        console.log(chalk.green(`\n✓ Transaction ID: ${tx.id}`));
+        console.log(`  Status: ${tx.status}`);
+        console.log(`  Amount: ${tx.amount} ${tx.currency}`);
+        
+        if (template.steps.some(s => s.async)) {
+          console.log(chalk.yellow('\n⚠️  Some steps are async and may require confirmation.'));
+          console.log(chalk.gray('Check status with: payment-skill transaction status ' + tx.id));
+        }
+      } catch (error: any) {
+        execSpinner.fail(chalk.red('Payment failed'));
+        throw error;
+      }
+    } catch (error: any) {
+      console.error(chalk.red('\nError:'), error.message);
+      process.exit(1);
+    }
+  });