payment-skill 1.0.0

package/src/commands/provider.ts

@@ -0,0 +1,75 @@
+/**
+ * Payment Skill - Provider Commands
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../core/config';
+
+export const providerCommands = new Command('provider')
+  .description('Manage payment providers');
+
+providerCommands
+  .command('add')
+  .description('Add a payment provider')
+  .argument('<name>', 'Provider name (wise, bunq)')
+  .requiredOption('-k, --api-key <key>', 'API key')
+  .option('-e, --environment <env>', 'Environment', 'production')
+  .option('--profile-id <id>', 'Wise profile ID')
+  .action((name, options) => {
+    const provider: any = {
+      name,
+      apiKey: options.apiKey,
+      environment: options.environment
+    };
+    
+    if (options.profileId) {
+      provider.profileId = options.profileId;
+    }
+    
+    configManager.setProvider(name, provider);
+    console.log(chalk.green(`✓ Provider '${name}' added`));
+  });
+
+providerCommands
+  .command('list')
+  .description('List configured providers')
+  .action(() => {
+    const providers = configManager.getAllProviders();
+    console.log(chalk.blue('Configured Providers:'));
+    Object.entries(providers).forEach(([name, config]: [string, any]) => {
+      console.log(`  ${name} - ${config.environment}`);
+    });
+  });
+
+providerCommands
+  .command('get')
+  .description('Get provider details')
+  .argument('<name>', 'Provider name')
+  .action((name) => {
+    const provider = configManager.getProvider(name);
+    if (provider) {
+      console.log(JSON.stringify(provider, null, 2));
+    } else {
+      console.log(chalk.yellow(`Provider '${name}' not found`));
+    }
+  });
+
+providerCommands
+  .command('remove')
+  .description('Remove a provider')
+  .argument('<name>', 'Provider name')
+  .action((name) => {
+    configManager.removeProvider(name);
+    console.log(chalk.green(`✓ Provider '${name}' removed`));
+  });
+
+providerCommands
+  .command('test')
+  .description('Test provider connection')
+  .argument('<name>', 'Provider name')
+  .action(async (name) => {
+    console.log(chalk.blue(`Testing connection to ${name}...`));
+    // Implementation would test actual connection
+    console.log(chalk.green('✓ Connection successful'));
+  });

package/src/commands/server.ts

@@ -0,0 +1,59 @@
+/**
+ * Payment Skill - Server Commands
+ * 
+ * Server management with actual implementation
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { PaymentSkillServer } from '../server/server';
+
+export const serverCommands = new Command('server')
+  .description('Server management');
+
+serverCommands
+  .command('serve', { isDefault: true })
+  .description('Start the dashboard server')
+  .option('-p, --port <port>', 'Port number', '8080')
+  .option('-h, --host <host>', 'Host address', 'localhost')
+  .action((options) => {
+    console.log(chalk.blue(`Starting Payment Skill server...`));
+    console.log(chalk.gray(`Port: ${options.port}`));
+    console.log(chalk.gray(`Host: ${options.host}`));
+    
+    const server = new PaymentSkillServer(parseInt(options.port));
+    server.start();
+    
+    console.log(chalk.green(`\n✓ Server started!`));
+    console.log(chalk.blue(`\nDashboard: http://${options.host}:${options.port}`));
+    console.log(chalk.gray(`API: http://${options.host}:${options.port}/api`));
+    console.log(chalk.gray(`Press Ctrl+C to stop`));
+  });
+
+serverCommands
+  .command('stop')
+  .description('Stop the server (not implemented - use Ctrl+C)')
+  .action(() => {
+    console.log(chalk.yellow('To stop the server, press Ctrl+C in the terminal where it\'s running'));
+  });
+
+serverCommands
+  .command('status')
+  .description('Check server status')
+  .option('-p, --port <port>', 'Port number', '8080')
+  .action(async (options) => {
+    try {
+      const fetch = (await import('node-fetch')).default;
+      const response = await fetch(`http://localhost:${options.port}/api/health`);
+      const data = await response.json();
+      
+      if (data.status === 'ok') {
+        console.log(chalk.green('✓ Server is running'));
+        console.log(`  Version: ${data.version}`);
+        console.log(`  Emergency Stop: ${data.emergencyStop ? chalk.red('ACTIVE') : chalk.green('inactive')}`);
+      }
+    } catch (error) {
+      console.log(chalk.red('✗ Server is not running'));
+      console.log(chalk.gray(`  Could not connect to port ${options.port}`));
+    }
+  });

package/src/commands/template.ts

@@ -0,0 +1,172 @@
+/**
+ * Payment Skill - Template Commands
+ * 
+ * Manage and execute payment templates
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { templateEngine } from '../core/template-engine';
+
+export const templateCommands = new Command('template')
+  .description('Payment templates - HYBRID ARCHITECTURE');
+
+templateCommands
+  .command('list')
+  .description('List available templates')
+  .option('-m, --merchant <merchant>', 'Filter by merchant (wise.com, bunq.com, stripe.com)')
+  .action((options) => {
+    let templates = templateEngine.getAllTemplates();
+    
+    if (options.merchant) {
+      templates = templates.filter(t => t.merchant === options.merchant);
+    }
+    
+    console.log(chalk.blue(`Available Templates (${templates.length}):\n`));
+    
+    templates.forEach(t => {
+      console.log(chalk.green(`${t.templateId}`));
+      console.log(`  Merchant: ${t.merchant}`);
+      console.log(`  Description: ${t.description}`);
+      console.log(`  Version: ${t.version}`);
+      console.log(`  Steps: ${t.steps.length}`);
+      
+      if (t.prerequisites.apiKey === 'required') {
+        console.log(chalk.yellow('  ⚠️  Requires API key'));
+      }
+      
+      console.log('');
+    });
+    
+    console.log(chalk.gray('Use "payment-skill template get <id>" for details'));
+    console.log(chalk.gray('Use "payment-skill pay --template <id> ..." to execute'));
+  });
+
+templateCommands
+  .command('get')
+  .description('Get template details')
+  .argument('<template-id>', 'Template ID')
+  .action((templateId) => {
+    const template = templateEngine.getTemplate(templateId);
+    
+    if (!template) {
+      console.log(chalk.yellow(`Template '${templateId}' not found`));
+      return;
+    }
+    
+    console.log(chalk.blue('Template Details:'));
+    console.log(`  ID: ${template.templateId}`);
+    console.log(`  Merchant: ${template.merchant}`);
+    console.log(`  Description: ${template.description}`);
+    console.log(`  Version: ${template.version}`);
+    
+    console.log(chalk.blue('\nPrerequisites:'));
+    console.log(`  API Key: ${template.prerequisites.apiKey}`);
+    if (template.prerequisites.webhookEndpoint) {
+      console.log(`  Webhook: ${template.prerequisites.webhookEndpoint}`);
+    }
+    
+    console.log(chalk.blue('\nExecution Steps:'));
+    template.steps.sort((a, b) => a.order - b.order).forEach(step => {
+      console.log(`\n  ${step.order}. ${step.name}`);
+      console.log(`     Command: ${step.command}`);
+      
+      if (Object.keys(step.params).length > 0) {
+        console.log('     Parameters:');
+        Object.entries(step.params).forEach(([key, value]) => {
+          console.log(`       ${key}: ${value}`);
+        });
+      }
+      
+      if (step.async) {
+        console.log(chalk.yellow('     [ASYNC]'));
+        if (step.confirmation) {
+          console.log(`     Confirmation: ${step.confirmation.type}`);
+          if (step.confirmation.timeout) {
+            console.log(`     Timeout: ${step.confirmation.timeout}s`);
+          }
+        }
+      }
+      
+      if (step.output) {
+        console.log('     Outputs:');
+        Object.entries(step.output).forEach(([key, path]) => {
+          console.log(`       ${key} -> ${path}`);
+        });
+      }
+    });
+    
+    console.log(chalk.blue('\nError Handling:'));
+    console.log(`  Retry on: ${template.errorHandling.retryOn.join(', ')}`);
+    console.log(`  Max retries: ${template.errorHandling.maxRetries}`);
+    if (template.errorHandling.fallback) {
+      console.log(`  Fallback: ${template.errorHandling.fallback}`);
+    }
+    
+    console.log(chalk.blue('\nExample Usage:'));
+    console.log(chalk.gray(`  payment-skill pay --template ${templateId} --amount 100 --currency EUR ...`));
+  });
+
+templateCommands
+  .command('validate')
+  .description('Validate template parameters without executing')
+  .requiredOption('-t, --template <id>', 'Template ID')
+  .option('--amount <amount>', 'Payment amount')
+  .option('--currency <currency>', 'Currency code')
+  .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 ID')
+  .option('--recipient-iban <iban>', 'Recipient IBAN')
+  .option('--recipient-name <name>', 'Recipient name')
+  .action((options) => {
+    const template = templateEngine.getTemplate(options.template);
+    
+    if (!template) {
+      console.log(chalk.red(`Template '${options.template}' not found`));
+      return;
+    }
+    
+    console.log(chalk.blue('Validating parameters for template:'), options.template);
+    
+    // Build params
+    const params: Record<string, any> = {};
+    if (options.amount) params.amount = options.amount;
+    if (options.currency) params.currency = options.currency;
+    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;
+    
+    // Check for missing required params
+    const requiredParams = new Set<string>();
+    template.steps.forEach(step => {
+      Object.values(step.params).forEach(value => {
+        if (typeof value === 'string') {
+          const matches = value.match(/\{\{(\w+)\}\}/g);
+          if (matches) {
+            matches.forEach(match => {
+              const paramName = match.replace(/\{\{|\}\}/g, '');
+              requiredParams.add(paramName);
+            });
+          }
+        }
+      });
+    });
+    
+    const missing = Array.from(requiredParams).filter(p => !params[p]);
+    
+    if (missing.length > 0) {
+      console.log(chalk.red('\n❌ Missing required parameters:'));
+      missing.forEach(p => console.log(`  - ${p}`));
+    } else {
+      console.log(chalk.green('\n✓ All required parameters provided'));
+    }
+    
+    console.log(chalk.blue('\nProvided parameters:'));
+    Object.entries(params).forEach(([key, value]) => {
+      console.log(`  ${key}: ${value}`);
+    });
+  });

package/src/commands/transaction.ts

@@ -0,0 +1,66 @@
+/**
+ * Payment Skill - Transaction Commands
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { transactionManager } from '../core/transaction';
+
+export const transactionCommands = new Command('transaction')
+  .description('Manage transactions');
+
+transactionCommands
+  .command('list')
+  .description('List transactions')
+  .option('-s, --status <status>', 'Filter by status')
+  .option('-p, --provider <provider>', 'Filter by provider')
+  .option('-m, --merchant <merchant>', 'Filter by merchant')
+  .option('--from <date>', 'From date (YYYY-MM-DD)')
+  .option('--to <date>', 'To date (YYYY-MM-DD)')
+  .action((options) => {
+    const filters: any = {};
+    if (options.status) filters.status = options.status;
+    if (options.provider) filters.provider = options.provider;
+    if (options.merchant) filters.merchant = options.merchant;
+    if (options.from) filters.from = new Date(options.from);
+    if (options.to) filters.to = new Date(options.to);
+    
+    const txs = transactionManager.getTransactions(filters);
+    console.log(chalk.blue(`Transactions (${txs.length}):`));
+    txs.forEach(tx => {
+      const statusColor = tx.status === 'completed' ? chalk.green : 
+                         tx.status === 'pending' ? chalk.yellow : chalk.red;
+      console.log(`  ${tx.id} - ${statusColor(tx.status)} - ${tx.amount} ${tx.currency} - ${tx.merchant}`);
+    });
+  });
+
+transactionCommands
+  .command('get')
+  .description('Get transaction details')
+  .argument('<id>', 'Transaction ID')
+  .action((id) => {
+    const tx = transactionManager.getTransaction(id);
+    if (tx) {
+      console.log(JSON.stringify(tx, null, 2));
+    } else {
+      console.log(chalk.yellow(`Transaction '${id}' not found`));
+    }
+  });
+
+transactionCommands
+  .command('cancel')
+  .description('Cancel a transaction')
+  .argument('<id>', 'Transaction ID')
+  .action((id) => {
+    transactionManager.updateTransactionStatus(id, 'cancelled');
+    console.log(chalk.green(`✓ Transaction ${id} cancelled`));
+  });
+
+transactionCommands
+  .command('delete')
+  .description('Delete a transaction')
+  .argument('<id>', 'Transaction ID')
+  .action((id) => {
+    transactionManager.deleteTransaction(id);
+    console.log(chalk.green(`✓ Transaction ${id} deleted`));
+  });

package/src/commands/wise.ts

@@ -0,0 +1,279 @@
+/**
+ * Payment Skill - Wise Commands
+ * 
+ * Wise API CLI commands
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { WiseClient } from '../api/wise';
+import { configManager } from '../core/config';
+import { transactionManager } from '../core/transaction';
+
+export const wiseCommands = new Command('wise')
+  .description('Wise API operations');
+
+// Balance commands
+wiseCommands
+  .command('balance')
+  .description('Get Wise account balances')
+  .option('-p, --profile <id>', 'Profile ID')
+  .action(async (options) => {
+    const spinner = ora('Fetching balances...').start();
+    try {
+      const config = configManager.getProvider('wise');
+      if (!config) {
+        throw new Error('Wise not configured. Run: payment-skill provider add wise');
+      }
+      
+      const client = new WiseClient(config as any);
+      const profileId = options.profile || config.profileId;
+      
+      if (!profileId) {
+        throw new Error('Profile ID required. Use --profile or set default');
+      }
+      
+      const balances = await client.getBalances(profileId);
+      spinner.stop();
+      
+      console.log(chalk.blue('Wise Balances:'));
+      balances.forEach((balance: any) => {
+        console.log(`  ${balance.currency}: ${balance.amount.value}`);
+      });
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });
+
+// Quote commands
+wiseCommands
+  .command('quote')
+  .description('Create a quote (lock exchange rate)')
+  .requiredOption('-s, --source <currency>', 'Source currency')
+  .requiredOption('-t, --target <currency>', 'Target currency')
+  .option('-a, --amount <amount>', 'Source amount')
+  .option('-p, --profile <id>', 'Profile ID')
+  .action(async (options) => {
+    const spinner = ora('Creating quote...').start();
+    try {
+      const config = configManager.getProvider('wise');
+      if (!config) {
+        throw new Error('Wise not configured');
+      }
+      
+      const client = new WiseClient(config as any);
+      const profileId = options.profile || config.profileId;
+      
+      const quote = await client.createQuote(
+        profileId,
+        options.source,
+        options.target,
+        parseFloat(options.amount)
+      );
+      
+      spinner.stop();
+      console.log(chalk.green('✓ Quote created'));
+      console.log(`  ID: ${quote.id}`);
+      console.log(`  Rate: ${quote.rate}`);
+      console.log(`  Fee: ${quote.fee}`);
+      console.log(`  Total: ${quote.sourceAmount}`);
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });
+
+// Transfer commands
+wiseCommands
+  .command('transfer')
+  .description('Create a transfer')
+  .requiredOption('-q, --quote <id>', 'Quote ID')
+  .requiredOption('-r, --recipient <id>', 'Recipient account ID')
+  .option('-m, --reference <text>', 'Payment reference')
+  .option('-p, --profile <id>', 'Profile ID')
+  .action(async (options) => {
+    const spinner = ora('Creating transfer...').start();
+    try {
+      const config = configManager.getProvider('wise');
+      if (!config) {
+        throw new Error('Wise not configured');
+      }
+      
+      // Create transaction record
+      const tx = transactionManager.createTransaction(
+        'wise',
+        'wise-transfer',
+        0, // Will update with actual amount
+        'EUR',
+        { quoteId: options.quote, recipientId: options.recipient }
+      );
+      
+      const client = new WiseClient(config as any);
+      const profileId = options.profile || config.profileId;
+      
+      const transfer = await client.createTransfer(
+        profileId,
+        options.quote,
+        options.recipient,
+        options.reference
+      );
+      
+      transactionManager.updateTransactionStatus(tx.id, 'initiated');
+      
+      spinner.stop();
+      console.log(chalk.green('✓ Transfer created'));
+      console.log(`  Transaction ID: ${tx.id}`);
+      console.log(`  Transfer ID: ${transfer.id}`);
+      console.log(`  Status: ${transfer.status}`);
+      
+      if (transfer.status === 'pending') {
+        console.log(chalk.yellow('\n⚠️  Transfer requires funding'));
+        console.log(`Run: payment-skill wise fund ${transfer.id}`);
+      }
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });
+
+// Fund transfer
+wiseCommands
+  .command('fund')
+  .description('Fund a transfer from balance')
+  .argument('<transferId>', 'Transfer ID to fund')
+  .option('-p, --profile <id>', 'Profile ID')
+  .action(async (transferId, options) => {
+    const spinner = ora('Funding transfer...').start();
+    try {
+      const config = configManager.getProvider('wise');
+      if (!config) {
+        throw new Error('Wise not configured');
+      }
+      
+      const client = new WiseClient(config as any);
+      const profileId = options.profile || config.profileId;
+      
+      const payment = await client.fundTransfer(profileId, transferId);
+      
+      spinner.stop();
+      console.log(chalk.green('✓ Transfer funded'));
+      console.log(`  Status: ${payment.status}`);
+      
+      if (payment.status === 'pending') {
+        console.log(chalk.yellow('\n⚠️  PSD2: Open Wise app to confirm'));
+      }
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });
+
+// List transfers
+wiseCommands
+  .command('list')
+  .description('List transfers')
+  .option('-p, --profile <id>', 'Profile ID')
+  .option('-s, --status <status>', 'Filter by status')
+  .option('-l, --limit <number>', 'Limit results', '10')
+  .action(async (options) => {
+    const spinner = ora('Fetching transfers...').start();
+    try {
+      const config = configManager.getProvider('wise');
+      if (!config) {
+        throw new Error('Wise not configured');
+      }
+      
+      const client = new WiseClient(config as any);
+      const profileId = options.profile || config.profileId;
+      
+      const transfers = await client.getTransfers(
+        profileId,
+        options.status,
+        parseInt(options.limit)
+      );
+      
+      spinner.stop();
+      console.log(chalk.blue(`Transfers (${transfers.length}):`));
+      transfers.forEach((t: any) => {
+        const statusColor = t.status === 'completed' ? chalk.green : 
+                           t.status === 'pending' ? chalk.yellow : chalk.red;
+        console.log(`  ${t.id} - ${statusColor(t.status)} - ${t.sourceValue} ${t.sourceCurrency}`);
+      });
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });
+
+// Get transfer status
+wiseCommands
+  .command('status')
+  .description('Get transfer status')
+  .argument('<transferId>', 'Transfer ID')
+  .option('--poll', 'Poll until completion')
+  .option('-i, --interval <seconds>', 'Poll interval', '5')
+  .action(async (transferId, options) => {
+    try {
+      const config = configManager.getProvider('wise');
+      if (!config) {
+        throw new Error('Wise not configured');
+      }
+      
+      const client = new WiseClient(config as any);
+      
+      if (options.poll) {
+        console.log(chalk.blue(`Polling transfer ${transferId}...`));
+        const spinner = ora('Waiting...').start();
+        
+        while (true) {
+          const transfer = await client.getTransfer(transferId);
+          spinner.text = `Status: ${transfer.status}`;
+          
+          if (transfer.status === 'completed') {
+            spinner.succeed(chalk.green(`Transfer completed!`));
+            break;
+          } else if (transfer.status === 'cancelled' || transfer.status === 'failed') {
+            spinner.fail(`Transfer ${transfer.status}`);
+            break;
+          }
+          
+          await new Promise(r => setTimeout(r, parseInt(options.interval) * 1000));
+        }
+      } else {
+        const transfer = await client.getTransfer(transferId);
+        console.log(chalk.blue('Transfer Status:'));
+        console.log(`  ID: ${transfer.id}`);
+        console.log(`  Status: ${transfer.status}`);
+        console.log(`  Amount: ${transfer.sourceValue} ${transfer.sourceCurrency}`);
+        console.log(`  Created: ${transfer.created}`);
+      }
+    } catch (error: any) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Cancel transfer
+wiseCommands
+  .command('cancel')
+  .description('Cancel a pending transfer')
+  .argument('<transferId>', 'Transfer ID to cancel')
+  .action(async (transferId) => {
+    const spinner = ora('Cancelling transfer...').start();
+    try {
+      const config = configManager.getProvider('wise');
+      if (!config) {
+        throw new Error('Wise not configured');
+      }
+      
+      const client = new WiseClient(config as any);
+      await client.cancelTransfer(transferId);
+      
+      spinner.succeed(chalk.green('Transfer cancelled'));
+    } catch (error: any) {
+      spinner.fail(error.message);
+      process.exit(1);
+    }
+  });