paymongo-cli 1.4.6 → 1.4.7

package/dist/commands/webhooks.js

@@ -6,6 +6,7 @@ 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();
@@ -54,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) {
@@ -153,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) {
@@ -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,4 +1,4 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
 import Logger from '../../utils/logger.js';
@@ -7,6 +7,7 @@ export class AnalyticsService {
     dataFile;
     logger;
     config;
+    _ready;
     constructor(config) {
         this.logger = new Logger();
         this.config = config;
@@ -14,36 +15,36 @@ export class AnalyticsService {
         this.dataFile = analyticsDir
             ? path.join(analyticsDir, 'analytics.json')
             : path.join(os.homedir(), '.paymongo-cli', 'analytics.json');
-        this.loadEvents();
+        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;
         }
@@ -56,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;
@@ -87,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: {

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) {

package/dist/services/dev/server.js

@@ -2,15 +2,18 @@ import * as http from 'http';
 import * as crypto from 'crypto';
 import chalk from 'chalk';
 import { AnalyticsService } from '../analytics/service.js';
+import Logger from '../../utils/logger.js';
 export class DevServer {
     server;
     port;
     config;
     analytics;
+    logger;
     constructor(port, config) {
         this.port = port;
         this.config = config;
         this.analytics = new AnalyticsService(config);
+        this.logger = new Logger();
         this.server = http.createServer((req, res) => {
             this.handleWebhookRequest(req, res);
         });
@@ -18,7 +21,7 @@ export class DevServer {
     async start() {
         return new Promise((resolve, reject) => {
             this.server.listen(this.port, () => {
-                console.log(chalk.green('✓'), `Webhook server listening on http://localhost:${this.port}`);
+                this.logger.success(`Webhook server listening on http://localhost:${this.port}`);
                 resolve();
             });
             this.server.on('error', (error) => {
@@ -29,7 +32,7 @@ export class DevServer {
     async stop() {
         return new Promise((resolve) => {
             this.server.close(() => {
-                console.log(chalk.yellow('✓'), 'Webhook server stopped');
+                this.logger.warning('Webhook server stopped');
                 resolve();
             });
         });
@@ -46,42 +49,45 @@ export class DevServer {
             body += chunk.toString();
         });
         req.on('end', () => {
-            try {
-                const event = JSON.parse(body);
-                const signatureValid = this.verifyWebhookSignature(req, body);
-                if (!signatureValid) {
-                    console.log(chalk.red('⚠️'), 'Webhook signature verification failed');
-                    res.writeHead(401, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'Invalid signature' }));
-                    this.analytics.recordEvent({
-                        type: event.data?.type || 'unknown',
-                        success: false,
-                        error: 'Invalid signature',
-                        data: event.data?.attributes,
-                    });
-                    return;
-                }
-                this.logWebhookEvent(event);
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ success: true }));
-            }
-            catch (error) {
-                console.error(chalk.red('✗'), 'Failed to process webhook:', error.message);
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Invalid JSON' }));
-                this.analytics.recordEvent({
-                    type: 'unknown',
+            void this.processWebhookBody(body, req, res);
+        });
+    }
+    async processWebhookBody(body, req, res) {
+        try {
+            const event = JSON.parse(body);
+            const signatureValid = this.verifyWebhookSignature(req, body);
+            if (!signatureValid) {
+                this.logger.failure('Webhook signature verification failed');
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid signature' }));
+                await this.analytics.recordEvent({
+                    type: event.data?.type || 'unknown',
                     success: false,
-                    error: 'Invalid JSON',
+                    error: 'Invalid signature',
+                    data: event.data?.attributes,
                 });
+                return;
             }
-        });
+            await this.logWebhookEvent(event);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true }));
+        }
+        catch (error) {
+            this.logger.error('Failed to process webhook:', error.message);
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid JSON' }));
+            await this.analytics.recordEvent({
+                type: 'unknown',
+                success: false,
+                error: 'Invalid JSON',
+            });
+        }
     }
-    logWebhookEvent(event) {
+    async logWebhookEvent(event) {
         const timestamp = new Date().toLocaleTimeString();
         const eventType = event.data?.type || 'unknown';
         const eventId = event.data?.id || 'unknown';
-        this.analytics.recordEvent({
+        await this.analytics.recordEvent({
             type: eventType,
             success: true,
             data: event.data?.attributes,
@@ -101,23 +107,23 @@ export class DevServer {
     }
     verifyWebhookSignature(req, body) {
         if (!this.config.dev.verifyWebhookSignatures) {
-            console.log(chalk.yellow('ℹ️'), 'Webhook signature verification disabled in config');
+            this.logger.warn('Webhook signature verification disabled in config');
             return true;
         }
         const signatureHeader = req.headers['paymongo-signature'];
         if (!signatureHeader) {
-            console.log(chalk.red('⚠️'), 'Signature verification required but no signature header found');
+            this.logger.failure('Signature verification required but no signature header found');
             return false;
         }
         const signatureParts = signatureHeader.split(',');
         if (signatureParts.length < 2) {
-            console.log(chalk.red('⚠️'), 'Invalid signature format');
+            this.logger.failure('Invalid signature format');
             return false;
         }
         const timestamp = signatureParts.find((part) => part.startsWith('t='))?.split('=')[1];
         const signature = signatureParts.find((part) => part.startsWith('te='))?.split('=')[1];
         if (!timestamp || !signature) {
-            console.log(chalk.red('⚠️'), 'Missing timestamp or signature in header');
+            this.logger.failure('Missing timestamp or signature in header');
             return false;
         }
         const webhookId = signatureParts.find((part) => part.startsWith('li='))?.split('=')[1];
@@ -130,12 +136,12 @@ export class DevServer {
         else {
             secretKeys = Object.values(webhookSecrets).filter((secret) => typeof secret === 'string' && secret.length > 0);
             if (webhookId && secretKeys.length > 0) {
-                console.log(chalk.yellow('⚠️'), `No webhook secret found for id ${webhookId}. Update your configuration.`);
+                this.logger.warning(`No webhook secret found for id ${webhookId}. Update your configuration.`);
                 return false;
             }
         }
         if (secretKeys.length === 0) {
-            console.log(chalk.yellow('⚠️'), 'Signature verification enabled but no webhook secrets configured');
+            this.logger.warning('Signature verification enabled but no webhook secrets configured');
             return true;
         }
         let isValid = false;
@@ -155,11 +161,11 @@ export class DevServer {
             }
         }
         if (isValid) {
-            console.log(chalk.green('✓'), 'Signature verified successfully');
+            this.logger.success('Signature verified successfully');
             return true;
         }
         else {
-            console.log(chalk.red('✗'), 'Signature verification failed');
+            this.logger.failure('Signature verification failed');
             return false;
         }
     }

package/dist/utils/bulk.js

@@ -32,8 +32,24 @@ export class BulkOperations {
         return filename;
     }
     static async importWebhooks(filename) {
-        const content = await fs.readFile(filename, 'utf-8');
-        const data = JSON.parse(content);
+        let content;
+        try {
+            content = await fs.readFile(filename, 'utf-8');
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT') {
+                throw new PayMongoError(`File not found: ${filename}`, 'FILE_NOT_FOUND', 404);
+            }
+            throw new PayMongoError(`Cannot read file: ${filename}`, 'FILE_READ_ERROR', 400);
+        }
+        let data;
+        try {
+            data = JSON.parse(content);
+        }
+        catch {
+            throw new PayMongoError(`Invalid JSON in ${filename}`, 'INVALID_JSON', 400);
+        }
         this.validateImportData(data, 'webhooks');
         return {
             webhooks: data.data,
@@ -41,8 +57,24 @@ export class BulkOperations {
         };
     }
     static async importPayments(filename) {
-        const content = await fs.readFile(filename, 'utf-8');
-        const data = JSON.parse(content);
+        let content;
+        try {
+            content = await fs.readFile(filename, 'utf-8');
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT') {
+                throw new PayMongoError(`File not found: ${filename}`, 'FILE_NOT_FOUND', 404);
+            }
+            throw new PayMongoError(`Cannot read file: ${filename}`, 'FILE_READ_ERROR', 400);
+        }
+        let data;
+        try {
+            data = JSON.parse(content);
+        }
+        catch {
+            throw new PayMongoError(`Invalid JSON in ${filename}`, 'INVALID_JSON', 400);
+        }
         this.validateImportData(data, 'payments');
         return {
             payments: data.data,

package/dist/utils/constants.js

@@ -12,10 +12,20 @@ export const ENVIRONMENTS = ['test', 'live'];
 export const CONFIG_FILE_NAME = '.paymongo';
 export const ENV_FILE_NAME = '.env';
 export const CLI_NAME = 'paymongo';
-export const CLI_VERSION = '1.0.0';
+import { createRequire } from 'module';
+const _require = createRequire(import.meta.url);
+const _pkg = _require('../../package.json');
+export const CLI_VERSION = _pkg.version;
 export const REQUEST_TIMEOUT = 30000;
 export const MAX_RETRIES = 3;
 export const RETRY_DELAY = 1000;
+export const CACHE_TTL = 2 * 60 * 1000;
+export const RATE_LIMIT_WINDOW_MS = 60 * 1000;
+export const RATE_LIMIT_DEFAULT_MAX = 100;
+export const RATE_LIMIT_WEBHOOKS_MAX = 30;
+export const RATE_LIMIT_PAYMENTS_MAX = 60;
+export const RATE_LIMIT_REFUNDS_MAX = 20;
+export const RATE_LIMIT_ENV_MULTIPLIER = 0.5;
 export const DEFAULT_DEV_PORT = 3000;
 export const DEFAULT_WEBHOOK_PATH = '/webhook';
 export const LOG_LEVELS = ['error', 'warn', 'info', 'debug'];

package/dist/utils/errors.js

@@ -56,6 +56,12 @@ export class WebhookError extends Error {
         this.name = 'WebhookError';
     }
 }
+export class CommandError extends Error {
+    constructor(message) {
+        super(message || 'Command failed');
+        this.name = 'CommandError';
+    }
+}
 export async function withRetry(operation, options = {}) {
     const { maxRetries = 3, delayMs = 1000, backoffMultiplier = 2, silent = false, retryCondition = (error) => {
         return (error.name === 'NetworkError' ||

package/dist/utils/validator.js

@@ -1,11 +1,5 @@
-export class ValidationError extends Error {
-    field;
-    constructor(message, field) {
-        super(message);
-        this.field = field;
-        this.name = 'ValidationError';
-    }
-}
+import { ValidationError } from './errors.js';
+export { ValidationError };
 export function validateApiKey(key, type) {
     if (!key || typeof key !== 'string') {
         return false;
@@ -16,7 +10,14 @@ export function validateApiKey(key, type) {
 }
 export function validateWebhookUrl(url) {
     try {
-        const parsedUrl = new URL(url);
+        const trimmed = url.trim();
+        if (trimmed.length > 2048) {
+            return false;
+        }
+        const parsedUrl = new URL(trimmed);
+        if (parsedUrl.username || parsedUrl.password) {
+            return false;
+        }
         return (parsedUrl.protocol === 'https:' ||
             parsedUrl.hostname === 'localhost' ||
             parsedUrl.hostname === '127.0.0.1');