@ktmcp-cli/nordigen 1.0.0

package/src/commands/institutions.js

@@ -0,0 +1,181 @@
+/**
+ * Institution Commands
+ *
+ * @fileoverview Commands for browsing and searching financial institutions
+ * @module commands/institutions
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createClient } from '../lib/api.js';
+import { ensureAuth } from '../lib/auth.js';
+import {
+  printJSON,
+  printError,
+  printSection,
+  printRow,
+  truncate,
+} from '../lib/output.js';
+
+export const institutionsCommand = new Command('institutions')
+  .description('Browse and search financial institutions')
+  .alias('inst');
+
+// List institutions
+institutionsCommand
+  .command('list')
+  .description('List supported institutions')
+  .requiredOption('-c, --country <code>', 'ISO 3166 country code (e.g., GB, DE, FR)')
+  .option('--payments', 'Filter institutions supporting payments')
+  .option('--account-selection', 'Filter institutions supporting account selection')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (options) => {
+    const spinner = ora('Fetching institutions...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+
+      const params = {};
+      if (options.payments) params.payments_enabled = true;
+      if (options.accountSelection) params.account_selection = true;
+
+      const institutions = await api.listInstitutions(options.country, params);
+
+      spinner.succeed(`Found ${institutions.length} institutions`);
+
+      if (options.json) {
+        printJSON(institutions);
+      } else {
+        printSection(`Institutions in ${options.country.toUpperCase()}`);
+
+        institutions.forEach((inst, index) => {
+          console.log(
+            chalk.cyan(`${(index + 1).toString().padStart(3)}.`),
+            chalk.bold(inst.name),
+            chalk.gray(`(${inst.id})`)
+          );
+
+          if (inst.bic) {
+            console.log('     BIC:', inst.bic);
+          }
+
+          const features = [];
+          if (inst.transaction_total_days) {
+            features.push(`${inst.transaction_total_days} days history`);
+          }
+          if (inst.payments_enabled) {
+            features.push('Payments');
+          }
+          if (inst.account_selection_supported) {
+            features.push('Account Selection');
+          }
+
+          if (features.length > 0) {
+            console.log('     Features:', chalk.green(features.join(', ')));
+          }
+
+          console.log();
+        });
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch institutions');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Get institution details
+institutionsCommand
+  .command('get')
+  .description('Get institution details')
+  .argument('<institution-id>', 'Institution ID')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (institutionId, options) => {
+    const spinner = ora('Fetching institution...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      const institution = await api.getInstitution(institutionId);
+
+      spinner.succeed('Institution retrieved');
+
+      if (options.json) {
+        printJSON(institution);
+      } else {
+        printSection('Institution Details');
+
+        printRow('ID', institution.id);
+        printRow('Name', institution.name);
+        if (institution.bic) printRow('BIC', institution.bic);
+        if (institution.countries) printRow('Countries', institution.countries.join(', '));
+        if (institution.logo) printRow('Logo', institution.logo);
+
+        printSection('Features');
+        printRow('Transaction History', institution.transaction_total_days ? `${institution.transaction_total_days} days` : 'N/A');
+        printRow('Payments', institution.payments_enabled ? chalk.green('Supported') : chalk.gray('Not supported'));
+        printRow('Account Selection', institution.account_selection_supported ? chalk.green('Supported') : chalk.gray('Not supported'));
+
+        if (institution.supported_payments) {
+          printRow('Payment Types', institution.supported_payments.join(', '));
+        }
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch institution');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Search institutions
+institutionsCommand
+  .command('search')
+  .description('Search for institutions by name')
+  .argument('<query>', 'Search query')
+  .requiredOption('-c, --country <code>', 'ISO 3166 country code')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (query, options) => {
+    const spinner = ora('Searching institutions...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      const institutions = await api.listInstitutions(options.country);
+
+      // Filter by name
+      const results = institutions.filter((inst) =>
+        inst.name.toLowerCase().includes(query.toLowerCase())
+      );
+
+      spinner.succeed(`Found ${results.length} matching institutions`);
+
+      if (options.json) {
+        printJSON(results);
+      } else {
+        if (results.length === 0) {
+          console.log(chalk.yellow('No institutions found matching query'));
+          return;
+        }
+
+        printSection('Search Results');
+
+        results.forEach((inst, index) => {
+          console.log(
+            chalk.cyan(`${(index + 1).toString().padStart(3)}.`),
+            chalk.bold(inst.name),
+            chalk.gray(`(${inst.id})`)
+          );
+          if (inst.bic) {
+            console.log('     BIC:', inst.bic);
+          }
+          console.log();
+        });
+      }
+    } catch (error) {
+      spinner.fail('Search failed');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });

package/src/commands/payments.js

@@ -0,0 +1,228 @@
+/**
+ * Payment Commands
+ *
+ * @fileoverview Commands for managing payments and creditors
+ * @module commands/payments
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createClient } from '../lib/api.js';
+import { ensureAuth } from '../lib/auth.js';
+import {
+  printJSON,
+  printSuccess,
+  printError,
+  printSection,
+  printRow,
+  formatStatus,
+  formatDateString,
+} from '../lib/output.js';
+
+export const paymentsCommand = new Command('payments')
+  .description('Manage payments and creditors')
+  .alias('pay');
+
+// List payments
+paymentsCommand
+  .command('list')
+  .description('List all payments')
+  .option('--limit <number>', 'Results per page', '100')
+  .option('--offset <number>', 'Pagination offset', '0')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (options) => {
+    const spinner = ora('Fetching payments...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+
+      const params = {
+        limit: parseInt(options.limit),
+        offset: parseInt(options.offset),
+      };
+
+      const data = await api.listPayments(params);
+
+      spinner.succeed(`Found ${data.count || data.results?.length || 0} payments`);
+
+      if (options.json) {
+        printJSON(data);
+      } else {
+        const payments = data.results || [];
+
+        if (payments.length === 0) {
+          console.log(chalk.yellow('No payments found'));
+          return;
+        }
+
+        printSection('Payments');
+
+        payments.forEach((payment, index) => {
+          console.log(chalk.cyan(`${index + 1}.`), chalk.bold(payment.id));
+          console.log('   Status:', formatStatus(payment.status));
+          console.log('   Created:', formatDateString(payment.created));
+
+          if (payment.amount && payment.currency) {
+            console.log('   Amount:', `${payment.amount} ${payment.currency}`);
+          }
+
+          console.log();
+        });
+
+        if (data.next) {
+          console.log(chalk.gray('More results available. Use --offset to paginate.'));
+        }
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch payments');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Get payment
+paymentsCommand
+  .command('get')
+  .description('Get payment details')
+  .argument('<payment-id>', 'Payment UUID')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (paymentId, options) => {
+    const spinner = ora('Fetching payment...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      const payment = await api.getPayment(paymentId);
+
+      spinner.succeed('Payment retrieved');
+
+      if (options.json) {
+        printJSON(payment);
+      } else {
+        printSection('Payment Details');
+        printRow('Payment ID', payment.id);
+        printRow('Status', formatStatus(payment.status));
+        printRow('Created', formatDateString(payment.created));
+
+        if (payment.amount && payment.currency) {
+          printRow('Amount', `${payment.amount} ${payment.currency}`);
+        }
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch payment');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Delete payment
+paymentsCommand
+  .command('delete')
+  .description('Delete a periodic payment')
+  .argument('<payment-id>', 'Payment UUID')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(async (paymentId, options) => {
+    if (!options.yes) {
+      console.log(chalk.yellow('Warning: This will permanently delete the payment'));
+      console.log('Use --yes to confirm deletion');
+      process.exit(0);
+    }
+
+    const spinner = ora('Deleting payment...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      await api.deletePayment(paymentId);
+
+      spinner.succeed('Payment deleted');
+      printSuccess('Payment deleted successfully');
+    } catch (error) {
+      spinner.fail('Failed to delete payment');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// List creditors
+paymentsCommand
+  .command('creditors')
+  .description('List payment creditors')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (options) => {
+    const spinner = ora('Fetching creditors...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      const data = await api.listCreditors();
+
+      spinner.succeed(`Found ${data.count || data.results?.length || 0} creditors`);
+
+      if (options.json) {
+        printJSON(data);
+      } else {
+        const creditors = data.results || [];
+
+        if (creditors.length === 0) {
+          console.log(chalk.yellow('No creditors found'));
+          return;
+        }
+
+        printSection('Payment Creditors');
+
+        creditors.forEach((creditor, index) => {
+          console.log(chalk.cyan(`${index + 1}.`), chalk.bold(creditor.name || creditor.id));
+          console.log('   ID:', creditor.id);
+
+          if (creditor.account) {
+            console.log('   Account:', creditor.account);
+          }
+
+          console.log();
+        });
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch creditors');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Get payment fields
+paymentsCommand
+  .command('fields')
+  .description('Get required payment fields for institution')
+  .argument('<institution-id>', 'Institution ID')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (institutionId, options) => {
+    const spinner = ora('Fetching payment fields...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      const fields = await api.getPaymentFields(institutionId);
+
+      spinner.succeed('Payment fields retrieved');
+
+      if (options.json) {
+        printJSON(fields);
+      } else {
+        printSection(`Required Payment Fields for ${institutionId}`);
+
+        if (Array.isArray(fields)) {
+          fields.forEach((field, index) => {
+            console.log(chalk.cyan(`${index + 1}.`), field);
+          });
+        } else {
+          console.log(chalk.yellow('No specific fields required'));
+        }
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch payment fields');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });

package/src/commands/requisitions.js

@@ -0,0 +1,239 @@
+/**
+ * Requisition Commands
+ *
+ * @fileoverview Commands for managing account requisitions
+ * @module commands/requisitions
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createClient } from '../lib/api.js';
+import { ensureAuth } from '../lib/auth.js';
+import {
+  printJSON,
+  printSuccess,
+  printError,
+  printSection,
+  printRow,
+  formatDateString,
+  formatStatus,
+} from '../lib/output.js';
+
+export const requisitionsCommand = new Command('requisitions')
+  .description('Manage account requisitions')
+  .alias('req');
+
+// List requisitions
+requisitionsCommand
+  .command('list')
+  .description('List all requisitions')
+  .option('--limit <number>', 'Results per page', '100')
+  .option('--offset <number>', 'Pagination offset', '0')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (options) => {
+    const spinner = ora('Fetching requisitions...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+
+      const params = {
+        limit: parseInt(options.limit),
+        offset: parseInt(options.offset),
+      };
+
+      const data = await api.listRequisitions(params);
+
+      spinner.succeed(`Found ${data.count || data.results?.length || 0} requisitions`);
+
+      if (options.json) {
+        printJSON(data);
+      } else {
+        const requisitions = data.results || [];
+
+        if (requisitions.length === 0) {
+          console.log(chalk.yellow('No requisitions found'));
+          return;
+        }
+
+        printSection('Requisitions');
+
+        requisitions.forEach((req, index) => {
+          console.log(chalk.cyan(`${index + 1}.`), chalk.bold(req.id));
+          console.log('   Status:', formatStatus(req.status));
+          console.log('   Institution:', req.institution_id);
+          console.log('   Created:', formatDateString(req.created));
+
+          if (req.reference) {
+            console.log('   Reference:', req.reference);
+          }
+
+          if (req.accounts && req.accounts.length > 0) {
+            console.log('   Accounts:', req.accounts.join(', '));
+          }
+
+          if (req.link) {
+            console.log('   Auth Link:', chalk.blue(req.link));
+          }
+
+          console.log();
+        });
+
+        if (data.next) {
+          console.log(chalk.gray('More results available. Use --offset to paginate.'));
+        }
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch requisitions');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Create requisition
+requisitionsCommand
+  .command('create')
+  .description('Create a new requisition')
+  .requiredOption('-i, --institution-id <id>', 'Institution ID')
+  .requiredOption('-r, --redirect <url>', 'Redirect URL after authentication')
+  .option('--reference <ref>', 'Custom reference identifier')
+  .option('--agreement <id>', 'Agreement UUID')
+  .option('--language <code>', 'User language code (e.g., en, de, fr)')
+  .option('--account-selection', 'Enable account selection')
+  .option('--redirect-immediate', 'Redirect immediately after auth')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (options) => {
+    const spinner = ora('Creating requisition...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+
+      const data = {
+        institution_id: options.institutionId,
+        redirect: options.redirect,
+      };
+
+      if (options.reference) data.reference = options.reference;
+      if (options.agreement) data.agreement = options.agreement;
+      if (options.language) data.user_language = options.language;
+      if (options.accountSelection) data.account_selection = true;
+      if (options.redirectImmediate) data.redirect_immediate = true;
+
+      const requisition = await api.createRequisition(data);
+
+      spinner.succeed('Requisition created');
+
+      if (options.json) {
+        printJSON(requisition);
+      } else {
+        printSection('Requisition Created');
+        printRow('Requisition ID', requisition.id);
+        printRow('Status', formatStatus(requisition.status));
+        printRow('Institution', requisition.institution_id);
+
+        if (requisition.reference) {
+          printRow('Reference', requisition.reference);
+        }
+
+        console.log();
+        printSuccess('Requisition created successfully');
+
+        if (requisition.link) {
+          console.log();
+          console.log(chalk.bold('Authentication Link:'));
+          console.log(chalk.blue(requisition.link));
+          console.log();
+          console.log(chalk.gray('Send this link to the end user to authorize access'));
+        }
+      }
+    } catch (error) {
+      spinner.fail('Failed to create requisition');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Get requisition
+requisitionsCommand
+  .command('get')
+  .description('Get requisition details')
+  .argument('<requisition-id>', 'Requisition UUID')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (requisitionId, options) => {
+    const spinner = ora('Fetching requisition...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      const requisition = await api.getRequisition(requisitionId);
+
+      spinner.succeed('Requisition retrieved');
+
+      if (options.json) {
+        printJSON(requisition);
+      } else {
+        printSection('Requisition Details');
+        printRow('Requisition ID', requisition.id);
+        printRow('Status', formatStatus(requisition.status));
+        printRow('Institution', requisition.institution_id);
+        printRow('Created', formatDateString(requisition.created));
+
+        if (requisition.reference) {
+          printRow('Reference', requisition.reference);
+        }
+
+        if (requisition.agreement) {
+          printRow('Agreement', requisition.agreement);
+        }
+
+        if (requisition.accounts && requisition.accounts.length > 0) {
+          console.log();
+          console.log(chalk.bold('Connected Accounts:'));
+          requisition.accounts.forEach((accountId, index) => {
+            console.log(chalk.cyan(`  ${index + 1}.`), accountId);
+          });
+        }
+
+        if (requisition.link) {
+          console.log();
+          console.log(chalk.bold('Authentication Link:'));
+          console.log(chalk.blue(requisition.link));
+        }
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch requisition');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Delete requisition
+requisitionsCommand
+  .command('delete')
+  .description('Delete a requisition')
+  .argument('<requisition-id>', 'Requisition UUID')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(async (requisitionId, options) => {
+    if (!options.yes) {
+      console.log(chalk.yellow('Warning: This will permanently delete the requisition'));
+      console.log('Use --yes to confirm deletion');
+      process.exit(0);
+    }
+
+    const spinner = ora('Deleting requisition...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      await api.deleteRequisition(requisitionId);
+
+      spinner.succeed('Requisition deleted');
+      printSuccess('Requisition deleted successfully');
+    } catch (error) {
+      spinner.fail('Failed to delete requisition');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });