paymongo-cli 1.4.4 → 1.4.7

package/dist/commands/trigger.js

@@ -5,6 +5,38 @@ import ConfigManager from '../services/config/manager.js';
 import Spinner from '../utils/spinner.js';
 import Logger from '../utils/logger.js';
 import WebhookEventStore from '../utils/webhook-store.js';
+import crypto from 'crypto';
+import { CLI_VERSION } from '../utils/constants.js';
+import { CommandError } from '../utils/errors.js';
+function buildSignatureHeader(config, webhookUrl, body) {
+    if (!config?.webhookSecrets || Object.keys(config.webhookSecrets).length === 0) {
+        return undefined;
+    }
+    const registered = config.registeredWebhooks || [];
+    const match = registered.find((w) => w.url === webhookUrl);
+    const webhookId = match?.id;
+    let secret;
+    if (webhookId && config.webhookSecrets[webhookId]) {
+        secret = config.webhookSecrets[webhookId];
+    }
+    else {
+        const secrets = Object.values(config.webhookSecrets).filter((value) => typeof value === 'string' && value.length > 0);
+        secret = secrets[0];
+    }
+    if (!secret) {
+        return undefined;
+    }
+    const timestamp = Math.floor(Date.now() / 1000).toString();
+    const signature = crypto
+        .createHmac('sha256', secret)
+        .update(`${timestamp}.${body}`)
+        .digest('hex');
+    const parts = [`t=${timestamp}`, `te=${signature}`];
+    if (webhookId) {
+        parts.push(`li=${webhookId}`);
+    }
+    return parts.join(',');
+}
 const command = new Command('trigger');
 command
     .description('Simulate webhook events locally')
@@ -89,11 +121,11 @@ async function sendWebhookEvent(options) {
         }
         if (!webhookUrl) {
             console.error(chalk.red('❌ No webhook URL provided. Use --url option or configure in .paymongo file'));
-            process.exit(1);
+            throw new CommandError();
         }
         if (!selectedEvent) {
             console.error(chalk.red('❌ No event selected'));
-            process.exit(1);
+            throw new CommandError();
         }
         spinner.start('Generating webhook payload...');
         const webhookPayload = generateWebhookPayload(selectedEvent);
@@ -122,13 +154,16 @@ async function sendWebhookEvent(options) {
         spinner.start('Sending webhook...');
         try {
             const { request } = await import('undici');
+            const body = JSON.stringify(webhookPayload);
+            const signatureHeader = buildSignatureHeader(config, webhookUrl, body);
             const response = await request(webhookUrl, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
-                    'User-Agent': 'PayMongo-CLI/1.0.0',
+                    'User-Agent': `PayMongo-CLI/${CLI_VERSION}`,
+                    ...(signatureHeader ? { 'paymongo-signature': signatureHeader } : {}),
                 },
-                body: JSON.stringify(webhookPayload),
+                body,
                 signal: AbortSignal.timeout(10000),
             });
             if (response.statusCode >= 200 && response.statusCode < 300) {
@@ -154,7 +189,7 @@ async function sendWebhookEvent(options) {
                 console.log(chalk.yellow('💡 To fix:'));
                 console.log(chalk.gray(`  • Verify your server has a POST handler at: ${webhookUrl}`));
                 console.log(chalk.gray('  • Check that your server is running and accessible'));
-                process.exit(1);
+                throw new CommandError();
             }
             else if (response.statusCode >= 400 && response.statusCode < 500) {
                 spinner.fail(`Webhook rejected by server (HTTP ${response.statusCode})`);
@@ -171,7 +206,7 @@ async function sendWebhookEvent(options) {
                 console.log(chalk.gray('  • Invalid request format or headers'));
                 console.log(chalk.gray('  • Authentication/authorization failure'));
                 console.log(chalk.gray('  • Webhook signature verification failed'));
-                process.exit(1);
+                throw new CommandError();
             }
             else if (response.statusCode >= 500) {
                 spinner.fail(`Webhook endpoint error (HTTP ${response.statusCode})`);
@@ -187,7 +222,7 @@ async function sendWebhookEvent(options) {
                 console.log(chalk.yellow('💡 This is a server-side error. Check:'));
                 console.log(chalk.gray('  • Server logs for the specific error'));
                 console.log(chalk.gray('  • Webhook handler code for exceptions'));
-                process.exit(1);
+                throw new CommandError();
             }
         }
         catch (error) {
@@ -205,7 +240,7 @@ async function sendWebhookEvent(options) {
                 console.log(chalk.yellow('💡 To fix:'));
                 console.log(chalk.gray('  • Start your local server'));
                 console.log(chalk.gray(`  • Verify the server is listening on the correct port`));
-                process.exit(1);
+                throw new CommandError();
             }
             else if (err.code === 'ENOTFOUND') {
                 spinner.fail('Host not found');
@@ -216,7 +251,7 @@ async function sendWebhookEvent(options) {
                 console.log(chalk.gray('  • The URL is spelled correctly'));
                 console.log(chalk.gray('  • Your internet connection is working'));
                 console.log(chalk.gray('  • DNS is resolving correctly'));
-                process.exit(1);
+                throw new CommandError();
             }
             else if (err.code === 'ETIMEDOUT' || err.message.includes('timeout')) {
                 spinner.fail('Request timed out');
@@ -231,7 +266,7 @@ async function sendWebhookEvent(options) {
                 console.log(chalk.yellow('💡 To fix:'));
                 console.log(chalk.gray('  • Check your webhook handler for slow operations'));
                 console.log(chalk.gray('  • Ensure async operations are handled properly'));
-                process.exit(1);
+                throw new CommandError();
             }
             else {
                 spinner.fail(`Webhook delivery failed: ${err.message}`);
@@ -241,7 +276,7 @@ async function sendWebhookEvent(options) {
                 if (err.code) {
                     console.log(chalk.gray(`   Code: ${err.code}`));
                 }
-                process.exit(1);
+                throw new CommandError();
             }
         }
     }
@@ -249,7 +284,7 @@ async function sendWebhookEvent(options) {
         const err = error;
         spinner.fail('Failed to trigger webhook event');
         logger.error('Trigger command error:', err.message);
-        process.exit(1);
+        throw new CommandError();
     }
 }
 function generateWebhookPayload(eventType) {
@@ -401,6 +436,8 @@ function generateWebhookPayload(eventType) {
 }
 async function replayWebhookEvent(eventId, options) {
     const store = new WebhookEventStore();
+    const configManager = new ConfigManager();
+    const config = await configManager.load();
     try {
         if (options.list || (!eventId && !options.event)) {
             const events = await store.loadEvents();
@@ -462,7 +499,7 @@ async function replayWebhookEvent(eventId, options) {
             if (!event) {
                 console.log(chalk.red(`❌ Event not found: ${eventId}`));
                 console.log(chalk.gray('Use "paymongo trigger replay --list" to see available events.'));
-                process.exit(1);
+                throw new CommandError();
             }
             const webhookUrl = options.url || event.url;
             console.log(chalk.bold.blue('\n🔄 Replaying Webhook Event'));
@@ -475,13 +512,16 @@ async function replayWebhookEvent(eventId, options) {
             spinner.start('Sending webhook...');
             try {
                 const { request } = await import('undici');
+                const body = JSON.stringify(event.payload);
+                const signatureHeader = buildSignatureHeader(config, webhookUrl, body);
                 const response = await request(webhookUrl, {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json',
-                        'User-Agent': 'PayMongo-CLI/1.0.0',
+                        'User-Agent': `PayMongo-CLI/${CLI_VERSION}`,
+                        ...(signatureHeader ? { 'paymongo-signature': signatureHeader } : {}),
                     },
-                    body: JSON.stringify(event.payload),
+                    body,
                     signal: AbortSignal.timeout(10000),
                 });
                 if (response.statusCode >= 200 && response.statusCode < 300) {
@@ -499,7 +539,7 @@ async function replayWebhookEvent(eventId, options) {
                 else {
                     spinner.fail(`Webhook replay failed (HTTP ${response.statusCode})`);
                     console.log(chalk.red(`Server responded with: ${response.statusCode}`));
-                    process.exit(1);
+                    throw new CommandError();
                 }
             }
             catch (error) {
@@ -511,14 +551,14 @@ async function replayWebhookEvent(eventId, options) {
                 else {
                     console.log(chalk.red(`❌ Error: ${err.message}`));
                 }
-                process.exit(1);
+                throw new CommandError();
             }
         }
     }
     catch (error) {
         const err = error;
         console.error(chalk.red(`❌ Failed to replay webhook: ${err.message}`));
-        process.exit(1);
+        throw new CommandError();
     }
 }
 function generateId() {

package/dist/commands/webhooks.js

@@ -1,12 +1,12 @@
 import Table from 'cli-table3';
 import { Command } from 'commander';
-import { input, checkbox } from '@inquirer/prompts';
 import chalk from 'chalk';
 import ConfigManager from '../services/config/manager.js';
 import ApiClient from '../services/api/client.js';
 import { BulkOperations } from '../utils/bulk.js';
 import Spinner from '../utils/spinner.js';
 import { validateWebhookUrl, validateEventTypes } from '../utils/validator.js';
+import { CommandError } from '../utils/errors.js';
 export async function exportAction(options) {
     const spinner = new Spinner();
     const configManager = new ConfigManager();
@@ -55,7 +55,7 @@ export async function exportAction(options) {
         spinner.stop();
         const err = error;
         console.error(chalk.red('❌ Failed to export webhooks:'), err.message);
-        process.exit(1);
+        throw new CommandError();
     }
 }
 export async function importAction(filename, options) {
@@ -154,7 +154,7 @@ export async function importAction(filename, options) {
         spinner.stop();
         const err = error;
         console.error(chalk.red('❌ Failed to import webhooks:'), err.message);
-        process.exit(1);
+        throw new CommandError();
     }
 }
 export async function createAction(options) {
@@ -178,6 +178,7 @@ export async function createAction(options) {
             };
         }
         else {
+            const { input, checkbox } = await import('@inquirer/prompts');
             const url = await input({
                 message: 'Webhook URL:',
                 default: options.url || '',
@@ -281,7 +282,7 @@ export async function createAction(options) {
             console.log('');
             console.log(chalk.yellow('💡 For help, visit: https://developers.paymongo.com/docs/webhooks'));
         }
-        process.exit(1);
+        throw new CommandError();
     }
 }
 export async function listAction(options) {
@@ -374,7 +375,7 @@ export async function listAction(options) {
         else {
             console.error(chalk.red('❌ Failed to list webhooks:'), err.message);
         }
-        process.exit(1);
+        throw new CommandError();
     }
 }
 export async function deleteAction(id, options) {
@@ -426,7 +427,7 @@ export async function deleteAction(id, options) {
         else {
             console.error(chalk.red('❌ Failed to delete webhook:'), err.message);
         }
-        process.exit(1);
+        throw new CommandError();
     }
 }
 export async function showAction(id) {
@@ -479,7 +480,7 @@ export async function showAction(id) {
         else {
             console.error(chalk.red('❌ Failed to get webhook details:'), err.message);
         }
-        process.exit(1);
+        throw new CommandError();
     }
 }
 const command = new Command('webhooks')

package/dist/index.js

@@ -2,6 +2,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { createRequire } from 'module';
+import { CommandError } from './utils/errors.js';
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
 const program = new Command();
@@ -68,11 +69,17 @@ EXAMPLES
 For more information, visit: https://github.com/leodyversemilla07/paymongo-cli
 `);
 process.on('uncaughtException', (error) => {
+    if (error instanceof CommandError) {
+        process.exit(1);
+    }
     console.error(chalk.red('An unexpected error occurred:'), error.message);
     process.exit(1);
 });
-process.on('unhandledRejection', (reason, promise) => {
-    console.error(chalk.red('Unhandled Rejection at:'), promise, 'reason:', reason);
+process.on('unhandledRejection', (reason) => {
+    if (reason instanceof CommandError) {
+        process.exit(1);
+    }
+    console.error(chalk.red('An unexpected error occurred:'), reason instanceof Error ? reason.message : String(reason));
     process.exit(1);
 });
 program.parse();

package/dist/services/analytics/service.js

@@ -1,45 +1,50 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import path from 'path';
+import os from 'os';
 import Logger from '../../utils/logger.js';
 export class AnalyticsService {
     events = [];
     dataFile;
     logger;
     config;
+    _ready;
     constructor(config) {
         this.logger = new Logger();
         this.config = config;
-        this.dataFile = path.join(process.cwd(), '.paymongo', 'analytics.json');
-        this.loadEvents();
+        const analyticsDir = process.env.PAYMONGO_ANALYTICS_DIR;
+        this.dataFile = analyticsDir
+            ? path.join(analyticsDir, 'analytics.json')
+            : path.join(os.homedir(), '.paymongo-cli', 'analytics.json');
+        this._ready = this.loadEvents();
     }
-    loadEvents() {
+    async loadEvents() {
         try {
-            if (fs.existsSync(this.dataFile)) {
-                const data = JSON.parse(fs.readFileSync(this.dataFile, 'utf-8'));
-                this.events = data.events || [];
-                if (this.events.length > 1000) {
-                    this.events = this.events.slice(-1000);
-                }
+            const data = JSON.parse(await fs.readFile(this.dataFile, 'utf-8'));
+            this.events = data.events || [];
+            if (this.events.length > 1000) {
+                this.events = this.events.slice(-1000);
             }
         }
         catch (error) {
+            if (error.code === 'ENOENT') {
+                return;
+            }
             this.logger.error('Failed to load analytics data', error);
             this.events = [];
         }
     }
-    saveEvents() {
+    async saveEvents() {
         try {
             const dir = path.dirname(this.dataFile);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            fs.writeFileSync(this.dataFile, JSON.stringify({ events: this.events }, null, 2));
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(this.dataFile, JSON.stringify({ events: this.events }, null, 2));
         }
         catch (error) {
             this.logger.error('Failed to save analytics data', error);
         }
     }
-    recordEvent(event) {
+    async recordEvent(event) {
+        await this._ready;
         if (!this.config.analytics?.enabled) {
             return;
         }
@@ -52,7 +57,7 @@ export class AnalyticsService {
         if (this.events.length > 1000) {
             this.events = this.events.slice(-1000);
         }
-        this.saveEvents();
+        await this.saveEvents();
     }
     getAnalytics() {
         const totalEvents = this.events.length;
@@ -83,8 +88,8 @@ export class AnalyticsService {
             errorsByType,
         };
     }
-    clearAnalytics() {
+    async clearAnalytics() {
         this.events = [];
-        this.saveEvents();
+        await this.saveEvents();
     }
 }

package/dist/services/api/client.js

@@ -2,7 +2,7 @@ import { request } from 'undici';
 import { NetworkError, ApiKeyError, PayMongoError, withRetry } from '../../utils/errors.js';
 import Cache from '../../utils/cache.js';
 import RateLimiter from './rate-limiter.js';
-const REQUEST_TIMEOUT = 30000;
+import { CLI_VERSION, REQUEST_TIMEOUT, CACHE_TTL, RATE_LIMIT_WINDOW_MS, RATE_LIMIT_DEFAULT_MAX, RATE_LIMIT_WEBHOOKS_MAX, RATE_LIMIT_PAYMENTS_MAX, RATE_LIMIT_REFUNDS_MAX, RATE_LIMIT_ENV_MULTIPLIER, PAYMONGO_API_BASE, } from '../../utils/constants.js';
 export class ApiClient {
     config;
     baseUrl;
@@ -12,13 +12,13 @@ export class ApiClient {
     rateLimiter;
     constructor(options) {
         this.config = options.config;
-        this.baseUrl = 'https://api.paymongo.com';
+        this.baseUrl = PAYMONGO_API_BASE;
         this.timeout = options.timeout || REQUEST_TIMEOUT;
         this.defaultHeaders = {
             'Content-Type': 'application/json',
-            'User-Agent': 'paymongo-cli/1.0.0',
+            'User-Agent': `paymongo-cli/${CLI_VERSION}`,
         };
-        this.cache = new Cache({ ttl: 2 * 60 * 1000 });
+        this.cache = new Cache({ ttl: CACHE_TTL });
         const rateLimitEnabled = options.enableRateLimiting !== false && this.config.rateLimiting?.enabled !== false;
         if (rateLimitEnabled) {
             const rateLimitConfig = options.rateLimitConfig || this.getDefaultRateLimitConfig();
@@ -42,26 +42,26 @@ export class ApiClient {
     getDefaultRateLimitConfig() {
         return {
             default: {
-                maxRequests: 100,
-                windowMs: 60 * 1000,
-                environmentMultiplier: 0.5,
+                maxRequests: RATE_LIMIT_DEFAULT_MAX,
+                windowMs: RATE_LIMIT_WINDOW_MS,
+                environmentMultiplier: RATE_LIMIT_ENV_MULTIPLIER,
             },
             endpoints: {
                 '/webhooks': {
-                    maxRequests: 30,
-                    windowMs: 60 * 1000,
+                    maxRequests: RATE_LIMIT_WEBHOOKS_MAX,
+                    windowMs: RATE_LIMIT_WINDOW_MS,
                 },
                 '/payments': {
-                    maxRequests: 60,
-                    windowMs: 60 * 1000,
+                    maxRequests: RATE_LIMIT_PAYMENTS_MAX,
+                    windowMs: RATE_LIMIT_WINDOW_MS,
                 },
                 '/payment_intents': {
-                    maxRequests: 60,
-                    windowMs: 60 * 1000,
+                    maxRequests: RATE_LIMIT_PAYMENTS_MAX,
+                    windowMs: RATE_LIMIT_WINDOW_MS,
                 },
                 '/refunds': {
-                    maxRequests: 20,
-                    windowMs: 60 * 1000,
+                    maxRequests: RATE_LIMIT_REFUNDS_MAX,
+                    windowMs: RATE_LIMIT_WINDOW_MS,
                 },
             },
             environments: {
@@ -93,7 +93,7 @@ export class ApiClient {
         const env = this.config.environment;
         const secretKey = this.config.apiKeys[env]?.secret;
         if (!secretKey) {
-            throw new Error('Secret API key not found');
+            throw new ApiKeyError('Secret API key not found', 'secret');
         }
         const headers = {
             ...this.defaultHeaders,

package/dist/services/config/manager.js

@@ -30,6 +30,12 @@ export class ConfigManager {
                 return null;
             }
             this.validateConfig(config);
+            if (!config.apiKeys) {
+                config.apiKeys = {};
+            }
+            if (!config.webhookSecrets) {
+                config.webhookSecrets = {};
+            }
             try {
                 const stats = fs.statSync(this.configPath);
                 this.configCache.set(this.configPath, {
@@ -119,14 +125,6 @@ export class ConfigManager {
             const field = firstError.includes(':') ? firstError.split(':')[0] : undefined;
             throw new ValidationError(firstError, field);
         }
-        const cfg = config;
-        const env = cfg.environment;
-        if (!cfg.apiKeys[env]) {
-            throw new ValidationError(`Config file is missing API keys for environment "${env}"`, `apiKeys.${env}`);
-        }
-        if (!cfg.apiKeys[env]?.secret) {
-            throw new ValidationError(`Config file is missing secret API key for environment "${env}"`, `apiKeys.${env}.secret`);
-        }
     }
     mergeConfig(base, updates) {
         return {

package/dist/services/dev/process-manager.js

@@ -1,4 +1,4 @@
-import * as fs from 'fs';
+import fs from 'fs/promises';
 import * as path from 'path';
 import * as os from 'os';
 import { execSync } from 'child_process';
@@ -6,31 +6,30 @@ const STATE_DIR = path.join(os.homedir(), '.paymongo-cli');
 const STATE_FILE = path.join(STATE_DIR, 'dev-server.json');
 const LOG_FILE = path.join(STATE_DIR, 'dev-server.log');
 export class DevProcessManager {
-    static saveState(state) {
-        if (!fs.existsSync(STATE_DIR)) {
-            fs.mkdirSync(STATE_DIR, { recursive: true });
-        }
-        fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+    static async saveState(state) {
+        await fs.mkdir(STATE_DIR, { recursive: true });
+        await fs.writeFile(STATE_FILE, JSON.stringify(state, null, 2));
     }
-    static loadState() {
+    static async loadState() {
         try {
-            if (!fs.existsSync(STATE_FILE)) {
-                return null;
-            }
-            const content = fs.readFileSync(STATE_FILE, 'utf-8');
+            const content = await fs.readFile(STATE_FILE, 'utf-8');
             return JSON.parse(content);
         }
-        catch {
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                return null;
+            }
             return null;
         }
     }
-    static clearState() {
+    static async clearState() {
         try {
-            if (fs.existsSync(STATE_FILE)) {
-                fs.unlinkSync(STATE_FILE);
-            }
+            await fs.unlink(STATE_FILE);
         }
-        catch {
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                return;
+            }
         }
     }
     static isProcessRunning(pid) {
@@ -56,32 +55,31 @@ export class DevProcessManager {
             return false;
         }
     }
-    static getLogFile() {
-        if (!fs.existsSync(STATE_DIR)) {
-            fs.mkdirSync(STATE_DIR, { recursive: true });
-        }
+    static async getLogFile() {
+        await fs.mkdir(STATE_DIR, { recursive: true });
         return LOG_FILE;
     }
-    static readLogs(lines = 50) {
+    static async readLogs(lines = 50) {
         try {
-            if (!fs.existsSync(LOG_FILE)) {
-                return [];
-            }
-            const content = fs.readFileSync(LOG_FILE, 'utf-8');
+            const content = await fs.readFile(LOG_FILE, 'utf-8');
             const allLines = content.split('\n').filter(line => line.trim());
             return allLines.slice(-lines);
         }
-        catch {
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                return [];
+            }
             return [];
         }
     }
-    static clearLogs() {
+    static async clearLogs() {
         try {
-            if (fs.existsSync(LOG_FILE)) {
-                fs.writeFileSync(LOG_FILE, '');
-            }
+            await fs.writeFile(LOG_FILE, '');
         }
-        catch {
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                return;
+            }
         }
     }
     static formatUptime(startedAt) {