@ktmcp-cli/nordigen 1.0.0

package/src/commands/accounts.js

@@ -0,0 +1,205 @@
+/**
+ * Account Commands
+ *
+ * @fileoverview Commands for managing and retrieving account data
+ * @module commands/accounts
+ */
+
+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,
+  printAccountSummary,
+  printTransaction,
+  formatCurrency,
+  formatDateString,
+  formatStatus,
+} from '../lib/output.js';
+
+export const accountsCommand = new Command('accounts')
+  .description('Account information and data retrieval')
+  .alias('acc');
+
+// Get account metadata
+accountsCommand
+  .command('get')
+  .description('Get account metadata')
+  .argument('<account-id>', 'Account UUID')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (accountId, options) => {
+    const spinner = ora('Fetching account...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      const account = await api.getAccount(accountId);
+
+      spinner.succeed('Account retrieved');
+
+      if (options.json) {
+        printJSON(account);
+      } else {
+        printAccountSummary(account);
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch account');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Get account balances
+accountsCommand
+  .command('balances')
+  .description('Get account balances')
+  .argument('<account-id>', 'Account UUID')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (accountId, options) => {
+    const spinner = ora('Fetching balances...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      const data = await api.getAccountBalances(accountId);
+
+      spinner.succeed('Balances retrieved');
+
+      if (options.json) {
+        printJSON(data);
+      } else {
+        printSection('Account Balances');
+
+        if (data.balances && data.balances.length > 0) {
+          data.balances.forEach((balance) => {
+            const amount = balance.balanceAmount || {};
+            const type = balance.balanceType || 'N/A';
+            console.log(
+              chalk.cyan(type.padEnd(20)),
+              formatCurrency(amount.amount, amount.currency),
+              balance.referenceDate ? chalk.gray(`(${formatDateString(balance.referenceDate)})`) : ''
+            );
+          });
+        } else {
+          console.log(chalk.yellow('No balance information available'));
+        }
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch balances');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Get account details
+accountsCommand
+  .command('details')
+  .description('Get account details')
+  .argument('<account-id>', 'Account UUID')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (accountId, options) => {
+    const spinner = ora('Fetching account details...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      const data = await api.getAccountDetails(accountId);
+
+      spinner.succeed('Account details retrieved');
+
+      if (options.json) {
+        printJSON(data);
+      } else {
+        printSection('Account Details');
+
+        const account = data.account || {};
+        if (account.iban) printRow('IBAN', account.iban);
+        if (account.bban) printRow('BBAN', account.bban);
+        if (account.name) printRow('Name', account.name);
+        if (account.product) printRow('Product', account.product);
+        if (account.cashAccountType) printRow('Type', account.cashAccountType);
+        if (account.currency) printRow('Currency', account.currency);
+        if (account.ownerName) printRow('Owner', account.ownerName);
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch account details');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Get account transactions
+accountsCommand
+  .command('transactions')
+  .description('Get account transactions')
+  .argument('<account-id>', 'Account UUID')
+  .option('--from <date>', 'Start date (YYYY-MM-DD)')
+  .option('--to <date>', 'End date (YYYY-MM-DD)')
+  .option('--premium', 'Use premium endpoint')
+  .option('--country <code>', 'Country code (required for premium)')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (accountId, options) => {
+    const spinner = ora('Fetching transactions...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+
+      const params = {};
+      if (options.from) params.date_from = options.from;
+      if (options.to) params.date_to = options.to;
+
+      let data;
+      if (options.premium) {
+        if (!options.country) {
+          spinner.fail('Country code required for premium transactions');
+          printError('Use --country <code> to specify country');
+          process.exit(1);
+        }
+        data = await api.getPremiumTransactions(accountId, options.country, params);
+      } else {
+        data = await api.getAccountTransactions(accountId, params);
+      }
+
+      spinner.succeed('Transactions retrieved');
+
+      if (options.json) {
+        printJSON(data);
+      } else {
+        printSection('Transactions');
+
+        const transactions = data.transactions?.booked || [];
+        const pending = data.transactions?.pending || [];
+
+        if (transactions.length > 0) {
+          console.log(chalk.bold('Booked Transactions:'));
+          console.log();
+          transactions.forEach((tx) => printTransaction(tx));
+        }
+
+        if (pending.length > 0) {
+          console.log();
+          console.log(chalk.bold('Pending Transactions:'));
+          console.log();
+          pending.forEach((tx) => printTransaction(tx));
+        }
+
+        if (transactions.length === 0 && pending.length === 0) {
+          console.log(chalk.yellow('No transactions found'));
+        }
+
+        console.log();
+        console.log(chalk.gray(`Total: ${transactions.length} booked, ${pending.length} pending`));
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch transactions');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });

package/src/commands/agreements.js

@@ -0,0 +1,241 @@
+/**
+ * End User Agreement Commands
+ *
+ * @fileoverview Commands for managing end user agreements (EUAs)
+ * @module commands/agreements
+ */
+
+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 agreementsCommand = new Command('agreements')
+  .description('Manage end user agreements (EUAs)')
+  .alias('eua');
+
+// List agreements
+agreementsCommand
+  .command('list')
+  .description('List all end user agreements')
+  .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 agreements...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+
+      const params = {
+        limit: parseInt(options.limit),
+        offset: parseInt(options.offset),
+      };
+
+      const data = await api.listAgreements(params);
+
+      spinner.succeed(`Found ${data.count || data.results?.length || 0} agreements`);
+
+      if (options.json) {
+        printJSON(data);
+      } else {
+        const agreements = data.results || [];
+
+        if (agreements.length === 0) {
+          console.log(chalk.yellow('No agreements found'));
+          return;
+        }
+
+        printSection('End User Agreements');
+
+        agreements.forEach((agreement, index) => {
+          console.log(chalk.cyan(`${index + 1}.`), chalk.bold(agreement.id));
+          console.log('   Institution:', agreement.institution_id);
+          console.log('   Created:', formatDateString(agreement.created));
+          console.log('   Max Historical Days:', agreement.max_historical_days);
+          console.log('   Access Valid For:', agreement.access_valid_for_days, 'days');
+          console.log('   Status:', formatStatus(agreement.accepted ? 'ACCEPTED' : 'PENDING'));
+
+          if (agreement.access_scope && agreement.access_scope.length > 0) {
+            console.log('   Access Scope:', agreement.access_scope.join(', '));
+          }
+
+          console.log();
+        });
+
+        if (data.next) {
+          console.log(chalk.gray('More results available. Use --offset to paginate.'));
+        }
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch agreements');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Create agreement
+agreementsCommand
+  .command('create')
+  .description('Create a new end user agreement')
+  .requiredOption('-i, --institution-id <id>', 'Institution ID')
+  .option('--max-days <days>', 'Maximum historical days', '90')
+  .option('--valid-days <days>', 'Access valid for days', '90')
+  .option('--scope <scopes...>', 'Access scope (balances, details, transactions)')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (options) => {
+    const spinner = ora('Creating agreement...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+
+      const data = {
+        institution_id: options.institutionId,
+        max_historical_days: parseInt(options.maxDays),
+        access_valid_for_days: parseInt(options.validDays),
+      };
+
+      if (options.scope) {
+        data.access_scope = options.scope;
+      }
+
+      const agreement = await api.createAgreement(data);
+
+      spinner.succeed('Agreement created');
+
+      if (options.json) {
+        printJSON(agreement);
+      } else {
+        printSection('Agreement Created');
+        printRow('Agreement ID', agreement.id);
+        printRow('Institution', agreement.institution_id);
+        printRow('Max Historical Days', agreement.max_historical_days);
+        printRow('Access Valid For', `${agreement.access_valid_for_days} days`);
+
+        if (agreement.access_scope) {
+          printRow('Access Scope', agreement.access_scope.join(', '));
+        }
+
+        printSuccess('Agreement created successfully');
+      }
+    } catch (error) {
+      spinner.fail('Failed to create agreement');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Get agreement
+agreementsCommand
+  .command('get')
+  .description('Get agreement details')
+  .argument('<agreement-id>', 'Agreement UUID')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (agreementId, options) => {
+    const spinner = ora('Fetching agreement...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      const agreement = await api.getAgreement(agreementId);
+
+      spinner.succeed('Agreement retrieved');
+
+      if (options.json) {
+        printJSON(agreement);
+      } else {
+        printSection('Agreement Details');
+        printRow('Agreement ID', agreement.id);
+        printRow('Institution', agreement.institution_id);
+        printRow('Created', formatDateString(agreement.created));
+        printRow('Max Historical Days', agreement.max_historical_days);
+        printRow('Access Valid For', `${agreement.access_valid_for_days} days`);
+        printRow('Status', formatStatus(agreement.accepted ? 'ACCEPTED' : 'PENDING'));
+
+        if (agreement.access_scope) {
+          printRow('Access Scope', agreement.access_scope.join(', '));
+        }
+      }
+    } catch (error) {
+      spinner.fail('Failed to fetch agreement');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Delete agreement
+agreementsCommand
+  .command('delete')
+  .description('Delete an end user agreement')
+  .argument('<agreement-id>', 'Agreement UUID')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(async (agreementId, options) => {
+    if (!options.yes) {
+      console.log(chalk.yellow('Warning: This will permanently delete the agreement'));
+      console.log('Use --yes to confirm deletion');
+      process.exit(0);
+    }
+
+    const spinner = ora('Deleting agreement...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+      await api.deleteAgreement(agreementId);
+
+      spinner.succeed('Agreement deleted');
+      printSuccess('Agreement deleted successfully');
+    } catch (error) {
+      spinner.fail('Failed to delete agreement');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Accept agreement
+agreementsCommand
+  .command('accept')
+  .description('Accept an end user agreement')
+  .argument('<agreement-id>', 'Agreement UUID')
+  .requiredOption('--user-agent <ua>', 'User agent string')
+  .requiredOption('--ip <address>', 'User IP address')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (agreementId, options) => {
+    const spinner = ora('Accepting agreement...').start();
+
+    try {
+      await ensureAuth();
+      const api = createClient();
+
+      const data = {
+        user_agent: options.userAgent,
+        ip_address: options.ip,
+      };
+
+      const agreement = await api.acceptAgreement(agreementId, data);
+
+      spinner.succeed('Agreement accepted');
+
+      if (options.json) {
+        printJSON(agreement);
+      } else {
+        printSuccess('Agreement accepted successfully');
+      }
+    } catch (error) {
+      spinner.fail('Failed to accept agreement');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });

package/src/commands/auth.js

@@ -0,0 +1,86 @@
+/**
+ * Authentication Commands
+ *
+ * @fileoverview Commands for authentication and token management
+ * @module commands/auth
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { login, logout, getAuthStatus } from '../lib/auth.js';
+import { printSuccess, printError, printSection, printRow, formatDuration } from '../lib/output.js';
+
+export const authCommand = new Command('auth')
+  .description('Authentication and token management');
+
+// Login command
+authCommand
+  .command('login')
+  .description('Authenticate with Nordigen API')
+  .requiredOption('--secret-id <id>', 'Secret ID from Nordigen dashboard')
+  .requiredOption('--secret-key <key>', 'Secret Key from Nordigen dashboard')
+  .action(async (options) => {
+    const spinner = ora('Authenticating...').start();
+
+    try {
+      const result = await login(options.secretId, options.secretKey);
+      spinner.succeed('Authentication successful');
+
+      printSection('Token Information');
+      printRow('Access Token Expires In', formatDuration(result.access_expires));
+      printRow('Refresh Token Expires In', formatDuration(result.refresh_expires));
+
+      printSuccess('Credentials saved securely');
+    } catch (error) {
+      spinner.fail('Authentication failed');
+      printError(error.message, error);
+      process.exit(1);
+    }
+  });
+
+// Logout command
+authCommand
+  .command('logout')
+  .description('Clear stored credentials')
+  .action(() => {
+    try {
+      logout();
+      printSuccess('Logged out successfully');
+    } catch (error) {
+      printError('Logout failed', error);
+      process.exit(1);
+    }
+  });
+
+// Status command
+authCommand
+  .command('status')
+  .description('Show authentication status')
+  .action(() => {
+    try {
+      const status = getAuthStatus();
+
+      printSection('Authentication Status');
+
+      if (status.authenticated) {
+        printRow('Status', chalk.green('Authenticated'));
+        printRow('Access Token', status.accessTokenValid ? chalk.green('Valid') : chalk.yellow('Expired'));
+        printRow('Refresh Token', status.refreshTokenValid ? chalk.green('Valid') : chalk.yellow('Expired'));
+
+        if (status.accessTokenValid) {
+          printRow('Access Expires In', formatDuration(status.accessExpiresIn));
+        }
+        if (status.refreshTokenValid) {
+          printRow('Refresh Expires In', formatDuration(status.refreshExpiresIn));
+        }
+      } else {
+        printRow('Status', chalk.red('Not Authenticated'));
+        console.log();
+        console.log('Login with:', chalk.cyan('nordigen auth login --secret-id <id> --secret-key <key>'));
+      }
+    } catch (error) {
+      printError('Failed to get auth status', error);
+      process.exit(1);
+    }
+  });

package/src/commands/config.js

@@ -0,0 +1,173 @@
+/**
+ * Configuration Commands
+ *
+ * @fileoverview Commands for managing CLI configuration
+ * @module commands/config
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getConfig, getConfigPath, clear } from '../lib/config.js';
+import { printJSON, printSuccess, printError, printSection, printRow } from '../lib/output.js';
+
+export const configCommand = new Command('config')
+  .description('Manage CLI configuration');
+
+// Show config
+configCommand
+  .command('show')
+  .description('Show current configuration')
+  .option('-j, --json', 'Output as JSON')
+  .option('--show-secrets', 'Show secret values (WARNING: sensitive)')
+  .action((options) => {
+    try {
+      const config = getConfig();
+      const data = config.store;
+
+      if (options.json) {
+        if (options.showSecrets) {
+          printJSON(data);
+        } else {
+          // Redact secrets
+          const safe = JSON.parse(JSON.stringify(data));
+          if (safe.auth) {
+            if (safe.auth.secret_key) safe.auth.secret_key = '***REDACTED***';
+            if (safe.auth.access_token) safe.auth.access_token = '***REDACTED***';
+            if (safe.auth.refresh_token) safe.auth.refresh_token = '***REDACTED***';
+          }
+          printJSON(safe);
+        }
+      } else {
+        printSection('Configuration');
+        printRow('Config File', getConfigPath());
+
+        console.log();
+        console.log(chalk.bold('Authentication:'));
+        if (data.auth) {
+          printRow('  Secret ID', data.auth.secret_id || 'Not set');
+          printRow('  Secret Key', options.showSecrets ? data.auth.secret_key : '***REDACTED***');
+          printRow('  Access Token', data.auth.access_token ? (options.showSecrets ? data.auth.access_token : '***REDACTED***') : 'Not set');
+          printRow('  Refresh Token', data.auth.refresh_token ? (options.showSecrets ? data.auth.refresh_token : '***REDACTED***') : 'Not set');
+        } else {
+          console.log(chalk.gray('  Not configured'));
+        }
+
+        console.log();
+        console.log(chalk.bold('Defaults:'));
+        if (data.defaults) {
+          printRow('  Country', data.defaults.country || 'Not set');
+          printRow('  Institution ID', data.defaults.institution_id || 'Not set');
+        } else {
+          console.log(chalk.gray('  Not configured'));
+        }
+      }
+    } catch (error) {
+      printError('Failed to show config', error);
+      process.exit(1);
+    }
+  });
+
+// Get config value
+configCommand
+  .command('get')
+  .description('Get configuration value')
+  .argument('<key>', 'Configuration key (dot notation, e.g., auth.secret_id)')
+  .action((key) => {
+    try {
+      const config = getConfig();
+      const value = config.get(key);
+
+      if (value === undefined) {
+        console.log(chalk.yellow(`Key '${key}' not found`));
+        process.exit(1);
+      }
+
+      if (typeof value === 'object') {
+        printJSON(value);
+      } else {
+        console.log(value);
+      }
+    } catch (error) {
+      printError('Failed to get config value', error);
+      process.exit(1);
+    }
+  });
+
+// Set config value
+configCommand
+  .command('set')
+  .description('Set configuration value')
+  .argument('<key>', 'Configuration key (dot notation)')
+  .argument('<value>', 'Value to set')
+  .action((key, value) => {
+    try {
+      const config = getConfig();
+
+      // Try to parse as JSON, otherwise use as string
+      let parsedValue = value;
+      try {
+        parsedValue = JSON.parse(value);
+      } catch {
+        // Keep as string
+      }
+
+      config.set(key, parsedValue);
+      printSuccess(`Set ${key} = ${value}`);
+    } catch (error) {
+      printError('Failed to set config value', error);
+      process.exit(1);
+    }
+  });
+
+// Delete config value
+configCommand
+  .command('delete')
+  .description('Delete configuration value')
+  .argument('<key>', 'Configuration key')
+  .action((key) => {
+    try {
+      const config = getConfig();
+      config.delete(key);
+      printSuccess(`Deleted ${key}`);
+    } catch (error) {
+      printError('Failed to delete config value', error);
+      process.exit(1);
+    }
+  });
+
+// Clear all config
+configCommand
+  .command('clear')
+  .description('Clear all configuration')
+  .option('-y, --yes', 'Skip confirmation')
+  .action((options) => {
+    if (!options.yes) {
+      console.log(chalk.yellow('Warning: This will clear all configuration including credentials'));
+      console.log('Use --yes to confirm');
+      process.exit(0);
+    }
+
+    try {
+      clear();
+      printSuccess('Configuration cleared');
+    } catch (error) {
+      printError('Failed to clear config', error);
+      process.exit(1);
+    }
+  });
+
+// Set default country
+configCommand
+  .command('set-country')
+  .description('Set default country code')
+  .argument('<code>', 'ISO 3166 country code (e.g., GB, DE, FR)')
+  .action((code) => {
+    try {
+      const config = getConfig();
+      config.set('defaults.country', code.toUpperCase());
+      printSuccess(`Default country set to ${code.toUpperCase()}`);
+    } catch (error) {
+      printError('Failed to set country', error);
+      process.exit(1);
+    }
+  });