@ktmcp-cli/nowpayments 1.0.0

package/src/commands/payment.js

@@ -0,0 +1,241 @@
+/**
+ * Payment command
+ *
+ * Create and manage cryptocurrency payments.
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const Table = require('cli-table3');
+const { makeRequest, handleApiError, displayResponse } = require('../lib/api');
+
+const command = new Command('payment');
+
+command
+  .description('Manage payments')
+  .summary('Create and query payment transactions');
+
+// Create a new payment
+command
+  .command('create')
+  .description('Create a new payment')
+  .requiredOption('-p, --price <amount>', 'Price amount')
+  .requiredOption('-c, --currency <currency>', 'Price currency (e.g., USD)')
+  .requiredOption('--pay-currency <currency>', 'Cryptocurrency to receive (e.g., BTC)')
+  .option('--ipn-url <url>', 'IPN callback URL')
+  .option('--order-id <id>', 'Your order ID')
+  .option('--order-description <desc>', 'Order description')
+  .option('--purchase-id <id>', 'Purchase ID')
+  .option('--payout-address <address>', 'Payout address')
+  .option('--payout-currency <currency>', 'Payout currency')
+  .option('--payout-extra-id <id>', 'Payout extra ID (for currencies that require it)')
+  .option('--fixed-rate', 'Use fixed rate')
+  .action(async (options) => {
+    try {
+      const price = parseFloat(options.price);
+
+      if (isNaN(price) || price <= 0) {
+        console.error(chalk.red('Error: Price must be a positive number'));
+        process.exit(1);
+      }
+
+      const paymentData = {
+        price_amount: price,
+        price_currency: options.currency.toUpperCase(),
+        pay_currency: options.payCurrency.toUpperCase(),
+        ipn_callback_url: options.ipnUrl,
+        order_id: options.orderId,
+        order_description: options.orderDescription,
+        purchase_id: options.purchaseId,
+        payout_address: options.payoutAddress,
+        payout_currency: options.payoutCurrency?.toUpperCase(),
+        payout_extra_id: options.payoutExtraId,
+        fixed_rate: options.fixedRate || false
+      };
+
+      // Remove undefined values
+      Object.keys(paymentData).forEach(key => {
+        if (paymentData[key] === undefined) {
+          delete paymentData[key];
+        }
+      });
+
+      const data = await makeRequest(command.parent.parent, '/payment', {
+        method: 'POST',
+        body: paymentData
+      });
+
+      displayResponse(command.parent.parent, data, (response) => {
+        console.log(chalk.green('\n✓ Payment created successfully'));
+        console.log(chalk.cyan('\nPayment Details:'));
+        console.log(chalk.bold('  Payment ID:'), response.payment_id);
+        console.log(chalk.bold('  Status:'), getStatusColor(response.payment_status));
+        console.log(chalk.bold('  Pay Address:'), chalk.yellow(response.pay_address));
+        console.log(chalk.bold('  Pay Amount:'), `${response.pay_amount} ${response.pay_currency}`);
+        console.log(chalk.bold('  Price:'), `${response.price_amount} ${response.price_currency}`);
+
+        if (response.order_id) {
+          console.log(chalk.bold('  Order ID:'), response.order_id);
+        }
+
+        console.log(chalk.gray('\n  Created:'), new Date(response.created_at).toLocaleString());
+
+        if (response.expiration_estimate_date) {
+          console.log(chalk.gray('  Expires:'), new Date(response.expiration_estimate_date).toLocaleString());
+        }
+      });
+    } catch (error) {
+      handleApiError(error);
+    }
+  });
+
+// Get payment details
+command
+  .command('get <payment-id>')
+  .description('Get payment details by ID')
+  .action(async (paymentId) => {
+    try {
+      const data = await makeRequest(command.parent.parent, `/payment/${paymentId}`);
+
+      displayResponse(command.parent.parent, data, (response) => {
+        console.log(chalk.cyan('\nPayment Details:'));
+
+        const table = new Table({
+          chars: { 'mid': '', 'left-mid': '', 'mid-mid': '', 'right-mid': '' }
+        });
+
+        table.push(
+          ['Payment ID', response.payment_id],
+          ['Status', getStatusColor(response.payment_status)],
+          ['Pay Address', response.pay_address],
+          ['Pay Amount', `${response.pay_amount} ${response.pay_currency}`],
+          ['Price', `${response.price_amount} ${response.price_currency}`],
+          ['Actually Paid', response.actually_paid ? `${response.actually_paid} ${response.pay_currency}` : 'N/A']
+        );
+
+        if (response.outcome_amount) {
+          table.push(['Outcome', `${response.outcome_amount} ${response.outcome_currency}`]);
+        }
+
+        if (response.order_id) {
+          table.push(['Order ID', response.order_id]);
+        }
+
+        if (response.order_description) {
+          table.push(['Description', response.order_description]);
+        }
+
+        table.push(
+          ['Created', new Date(response.created_at).toLocaleString()],
+          ['Updated', new Date(response.updated_at).toLocaleString()]
+        );
+
+        console.log(table.toString());
+      });
+    } catch (error) {
+      handleApiError(error);
+    }
+  });
+
+// List payments
+command
+  .command('list')
+  .description('List all payments')
+  .option('-l, --limit <number>', 'Number of payments to return', '10')
+  .option('-p, --page <number>', 'Page number', '0')
+  .option('--sort-by <field>', 'Sort by field (created_at, updated_at)')
+  .option('--order <order>', 'Sort order (asc, desc)', 'desc')
+  .option('--date-from <date>', 'Filter by start date (YYYY-MM-DD)')
+  .option('--date-to <date>', 'Filter by end date (YYYY-MM-DD)')
+  .action(async (options) => {
+    try {
+      const queryParams = {
+        limit: parseInt(options.limit),
+        page: parseInt(options.page),
+        sortBy: options.sortBy,
+        orderBy: options.order,
+        dateFrom: options.dateFrom,
+        dateTo: options.dateTo
+      };
+
+      const data = await makeRequest(command.parent.parent, '/payment', {
+        queryParams
+      });
+
+      displayResponse(command.parent.parent, data, (response) => {
+        const payments = response.data || [];
+
+        if (payments.length === 0) {
+          console.log(chalk.yellow('\nNo payments found'));
+          return;
+        }
+
+        console.log(chalk.cyan(`\nPayments (${payments.length}):`));
+
+        const table = new Table({
+          head: ['ID', 'Status', 'Amount', 'Currency', 'Created'],
+          colWidths: [15, 15, 15, 10, 25]
+        });
+
+        payments.forEach(payment => {
+          table.push([
+            payment.payment_id?.toString().substring(0, 12) || 'N/A',
+            getStatusColor(payment.payment_status),
+            payment.pay_amount || 'N/A',
+            payment.pay_currency || 'N/A',
+            new Date(payment.created_at).toLocaleString()
+          ]);
+        });
+
+        console.log(table.toString());
+      });
+    } catch (error) {
+      handleApiError(error);
+    }
+  });
+
+// Update payment estimate
+command
+  .command('update-estimate <payment-id>')
+  .description('Update merchant estimate for a payment')
+  .action(async (paymentId) => {
+    try {
+      const data = await makeRequest(command.parent.parent, `/payment/${paymentId}/update-merchant-estimate`, {
+        method: 'POST'
+      });
+
+      displayResponse(command.parent.parent, data, (response) => {
+        console.log(chalk.green('\n✓ Estimate updated successfully'));
+        console.log(chalk.cyan('\nUpdated Payment:'));
+        console.log(chalk.bold('  Payment ID:'), response.payment_id);
+        console.log(chalk.bold('  Status:'), getStatusColor(response.payment_status));
+        console.log(chalk.bold('  New Pay Amount:'), `${response.pay_amount} ${response.pay_currency}`);
+      });
+    } catch (error) {
+      handleApiError(error);
+    }
+  });
+
+/**
+ * Get colored status text
+ * @param {string} status - Payment status
+ * @returns {string} Colored status
+ */
+function getStatusColor(status) {
+  const colors = {
+    'waiting': chalk.yellow,
+    'confirming': chalk.cyan,
+    'confirmed': chalk.blue,
+    'sending': chalk.magenta,
+    'partially_paid': chalk.yellow,
+    'finished': chalk.green,
+    'failed': chalk.red,
+    'refunded': chalk.gray,
+    'expired': chalk.red
+  };
+
+  const color = colors[status] || chalk.white;
+  return color(status);
+}
+
+module.exports = command;

package/src/commands/payout.js

@@ -0,0 +1,184 @@
+/**
+ * Payout command
+ *
+ * Create and manage cryptocurrency payouts/withdrawals.
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const Table = require('cli-table3');
+const { makeRequest, handleApiError, displayResponse } = require('../lib/api');
+
+const command = new Command('payout');
+
+command
+  .description('Manage payouts and withdrawals')
+  .summary('Create and query payout transactions');
+
+// Create a new payout
+command
+  .command('create')
+  .description('Create a new payout/withdrawal')
+  .requiredOption('-a, --amount <amount>', 'Payout amount')
+  .requiredOption('-c, --currency <currency>', 'Cryptocurrency (e.g., BTC)')
+  .requiredOption('--address <address>', 'Destination wallet address')
+  .option('--ipn-url <url>', 'IPN callback URL')
+  .option('--extra-id <id>', 'Extra ID for currencies that require it (e.g., XRP destination tag)')
+  .action(async (options) => {
+    try {
+      const amount = parseFloat(options.amount);
+
+      if (isNaN(amount) || amount <= 0) {
+        console.error(chalk.red('Error: Amount must be a positive number'));
+        process.exit(1);
+      }
+
+      const payoutData = {
+        withdrawals: [{
+          address: options.address,
+          currency: options.currency.toUpperCase(),
+          amount: amount,
+          ipn_callback_url: options.ipnUrl,
+          extra_id: options.extraId
+        }]
+      };
+
+      const data = await makeRequest(command.parent.parent, '/payout', {
+        method: 'POST',
+        body: payoutData
+      });
+
+      displayResponse(command.parent.parent, data, (response) => {
+        console.log(chalk.green('\n✓ Payout created successfully'));
+        console.log(chalk.cyan('\nPayout Details:'));
+
+        if (response.withdrawals && response.withdrawals.length > 0) {
+          const payout = response.withdrawals[0];
+          console.log(chalk.bold('  Payout ID:'), payout.id);
+          console.log(chalk.bold('  Status:'), payout.status);
+          console.log(chalk.bold('  Amount:'), `${payout.amount} ${payout.currency}`);
+          console.log(chalk.bold('  Address:'), payout.address);
+
+          if (payout.extra_id) {
+            console.log(chalk.bold('  Extra ID:'), payout.extra_id);
+          }
+        }
+
+        console.log(chalk.yellow('\n⚠ Note: Some payouts may require 2FA verification'));
+      });
+    } catch (error) {
+      handleApiError(error);
+    }
+  });
+
+// Verify payout (2FA)
+command
+  .command('verify <payout-id> <verification-code>')
+  .description('Verify a payout with 2FA code')
+  .action(async (payoutId, code) => {
+    try {
+      const data = await makeRequest(command.parent.parent, `/payout/${payoutId}/verify`, {
+        method: 'POST',
+        body: { verification_code: code }
+      });
+
+      displayResponse(command.parent.parent, data, (response) => {
+        console.log(chalk.green('\n✓ Payout verified successfully'));
+        console.log(chalk.cyan('\nStatus:'), response.status || 'Verified');
+      });
+    } catch (error) {
+      handleApiError(error);
+    }
+  });
+
+// Get payout details
+command
+  .command('get <payout-id>')
+  .description('Get payout details by ID')
+  .action(async (payoutId) => {
+    try {
+      const data = await makeRequest(command.parent.parent, `/payout/${payoutId}`);
+
+      displayResponse(command.parent.parent, data, (response) => {
+        console.log(chalk.cyan('\nPayout Details:'));
+
+        const table = new Table({
+          chars: { 'mid': '', 'left-mid': '', 'mid-mid': '', 'right-mid': '' }
+        });
+
+        table.push(
+          ['Payout ID', response.id],
+          ['Status', response.status],
+          ['Amount', `${response.amount} ${response.currency}`],
+          ['Address', response.address]
+        );
+
+        if (response.extra_id) {
+          table.push(['Extra ID', response.extra_id]);
+        }
+
+        if (response.hash) {
+          table.push(['Transaction Hash', response.hash]);
+        }
+
+        table.push(
+          ['Created', new Date(response.created_at).toLocaleString()]
+        );
+
+        console.log(table.toString());
+      });
+    } catch (error) {
+      handleApiError(error);
+    }
+  });
+
+// List payouts
+command
+  .command('list')
+  .description('List all payouts')
+  .option('-l, --limit <number>', 'Number of payouts to return', '10')
+  .option('-p, --page <number>', 'Page number', '0')
+  .action(async (options) => {
+    try {
+      const queryParams = {
+        limit: parseInt(options.limit),
+        page: parseInt(options.page)
+      };
+
+      const data = await makeRequest(command.parent.parent, '/payout', {
+        queryParams
+      });
+
+      displayResponse(command.parent.parent, data, (response) => {
+        const payouts = response.data || [];
+
+        if (payouts.length === 0) {
+          console.log(chalk.yellow('\nNo payouts found'));
+          return;
+        }
+
+        console.log(chalk.cyan(`\nPayouts (${payouts.length}):`));
+
+        const table = new Table({
+          head: ['ID', 'Status', 'Amount', 'Currency', 'Created'],
+          colWidths: [20, 15, 15, 10, 25]
+        });
+
+        payouts.forEach(payout => {
+          table.push([
+            payout.id?.toString().substring(0, 18) || 'N/A',
+            payout.status || 'N/A',
+            payout.amount || 'N/A',
+            payout.currency || 'N/A',
+            new Date(payout.created_at).toLocaleString()
+          ]);
+        });
+
+        console.log(table.toString());
+      });
+    } catch (error) {
+      handleApiError(error);
+    }
+  });
+
+module.exports = command;

package/src/commands/status.js

@@ -0,0 +1,28 @@
+/**
+ * Status command
+ *
+ * Check API status and availability.
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const { makeRequest, handleApiError, displayResponse } = require('../lib/api');
+
+const command = new Command('status');
+
+command
+  .description('Check NOWPayments API status')
+  .summary('Verify API connectivity and status')
+  .action(async () => {
+    try {
+      const data = await makeRequest(command.parent, '/status');
+
+      displayResponse(command.parent, data, (response) => {
+        console.log(chalk.green('✓ NOWPayments API is'), chalk.bold(response.message || 'OK'));
+      });
+    } catch (error) {
+      handleApiError(error);
+    }
+  });
+
+module.exports = command;

package/src/lib/api.js

@@ -0,0 +1,133 @@
+/**
+ * API client for NOWPayments
+ *
+ * Handles all HTTP requests to the NOWPayments API with proper error handling,
+ * authentication, and response formatting.
+ */
+
+const fetch = require('node-fetch');
+const chalk = require('chalk');
+const { getBaseUrl } = require('./config');
+const { getAuthHeaders } = require('./auth');
+
+/**
+ * Make an API request to NOWPayments
+ * @param {Object} program - Commander program instance
+ * @param {string} endpoint - API endpoint (e.g., '/status')
+ * @param {Object} options - Request options
+ * @param {string} options.method - HTTP method (GET, POST, etc.)
+ * @param {Object} options.body - Request body for POST/PUT requests
+ * @param {Object} options.queryParams - URL query parameters
+ * @returns {Promise<Object>} API response data
+ */
+async function makeRequest(program, endpoint, options = {}) {
+  const { method = 'GET', body = null, queryParams = {} } = options;
+
+  // Build URL
+  const baseUrl = getBaseUrl(program._sandbox);
+  const url = new URL(`${baseUrl}${endpoint}`);
+
+  // Add query parameters
+  Object.keys(queryParams).forEach(key => {
+    if (queryParams[key] !== undefined && queryParams[key] !== null) {
+      url.searchParams.append(key, queryParams[key]);
+    }
+  });
+
+  // Build request options
+  const requestOptions = {
+    method,
+    headers: getAuthHeaders(program)
+  };
+
+  // Add body for POST/PUT requests
+  if (body && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+    requestOptions.body = JSON.stringify(body);
+  }
+
+  if (program._debug) {
+    console.log(chalk.gray(`[DEBUG] ${method} ${url.toString()}`));
+    if (body) {
+      console.log(chalk.gray(`[DEBUG] Body: ${JSON.stringify(body, null, 2)}`));
+    }
+  }
+
+  try {
+    const response = await fetch(url.toString(), requestOptions);
+    const data = await response.json();
+
+    if (program._debug) {
+      console.log(chalk.gray(`[DEBUG] Status: ${response.status}`));
+      console.log(chalk.gray(`[DEBUG] Response: ${JSON.stringify(data, null, 2)}`));
+    }
+
+    // Handle error responses
+    if (!response.ok) {
+      const error = new Error(data.message || `API request failed with status ${response.status}`);
+      error.statusCode = response.status;
+      error.data = data;
+      throw error;
+    }
+
+    return data;
+  } catch (error) {
+    if (error.statusCode) {
+      // API error
+      throw error;
+    } else if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED') {
+      // Network error
+      const networkError = new Error('Network error: Unable to reach NOWPayments API');
+      networkError.originalError = error;
+      throw networkError;
+    } else {
+      // Other error (parsing, etc.)
+      throw error;
+    }
+  }
+}
+
+/**
+ * Handle and format API errors for display
+ * @param {Error} error - Error object
+ */
+function handleApiError(error) {
+  if (error.statusCode) {
+    console.error(chalk.red(`\nAPI Error (${error.statusCode}):`));
+    console.error(chalk.yellow(error.message));
+
+    if (error.data && error.data.errors) {
+      console.error(chalk.yellow('\nDetails:'));
+      console.error(JSON.stringify(error.data.errors, null, 2));
+    }
+  } else if (error.originalError) {
+    console.error(chalk.red('\nNetwork Error:'));
+    console.error(chalk.yellow(error.message));
+  } else {
+    console.error(chalk.red('\nUnexpected Error:'));
+    console.error(chalk.yellow(error.message));
+  }
+
+  process.exit(1);
+}
+
+/**
+ * Format and display API response
+ * @param {Object} program - Commander program instance
+ * @param {Object} data - Response data
+ * @param {Function} formatter - Optional custom formatter function
+ */
+function displayResponse(program, data, formatter = null) {
+  if (program._json) {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (formatter) {
+    formatter(data);
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+
+module.exports = {
+  makeRequest,
+  handleApiError,
+  displayResponse
+};

package/src/lib/auth.js

@@ -0,0 +1,70 @@
+/**
+ * Authentication utilities for NOWPayments CLI
+ *
+ * Handles API key validation and authentication headers.
+ */
+
+const chalk = require('chalk');
+const { getApiKey } = require('./config');
+
+/**
+ * Validate that an API key is available
+ * @param {Object} program - Commander program instance
+ * @throws {Error} If no API key is found
+ */
+function requireApiKey(program) {
+  const apiKey = getApiKey(program);
+
+  if (!apiKey) {
+    console.error(chalk.red('Error: No API key found'));
+    console.error(chalk.yellow('\nPlease set your API key using one of these methods:'));
+    console.error('  1. Environment variable: export NOWPAYMENTS_API_KEY=your_key');
+    console.error('  2. .env file: NOWPAYMENTS_API_KEY=your_key');
+    console.error('  3. Command flag: --api-key your_key');
+    console.error('  4. Save to config: nowpayments auth set your_key');
+    console.error(chalk.cyan('\nGet your API key at: https://nowpayments.io'));
+    process.exit(1);
+  }
+
+  return apiKey;
+}
+
+/**
+ * Get authentication headers for API requests
+ * @param {Object} program - Commander program instance
+ * @returns {Object} Headers object with authentication
+ */
+function getAuthHeaders(program) {
+  const apiKey = requireApiKey(program);
+
+  return {
+    'x-api-key': apiKey,
+    'Content-Type': 'application/json'
+  };
+}
+
+/**
+ * Validate API key format (basic check)
+ * @param {string} apiKey - API key to validate
+ * @returns {boolean} Whether the key appears valid
+ */
+function validateApiKeyFormat(apiKey) {
+  // Basic validation - NOWPayments API keys are typically alphanumeric
+  if (!apiKey || typeof apiKey !== 'string') {
+    return false;
+  }
+
+  // Check length (typical API keys are 32-64 characters)
+  if (apiKey.length < 20 || apiKey.length > 100) {
+    return false;
+  }
+
+  // Check for valid characters (alphanumeric and common symbols)
+  return /^[a-zA-Z0-9_-]+$/.test(apiKey);
+}
+
+module.exports = {
+  requireApiKey,
+  getAuthHeaders,
+  validateApiKeyFormat
+};