paymongo-cli 1.4.12 → 1.4.13

package/dist/commands/webhooks/actions.js

@@ -1,5 +1,5 @@
-import Table from 'cli-table3';
 import chalk from 'chalk';
+import Table from 'cli-table3';
 import { BulkOperations } from '../../utils/bulk.js';
 import { CommandError } from '../../utils/errors.js';
 import { validateEventTypes, validateWebhookUrl } from '../../utils/validator.js';
@@ -24,7 +24,7 @@ export async function exportAction(options) {
         spinner.start(`Exporting to ${filename}...`);
         await BulkOperations.exportWebhooks(webhooks, filename, config.environment);
         spinner.succeed('Export completed');
-        console.log('\n' + chalk.green('✅ Webhooks exported successfully!'));
+        console.log(`\n${chalk.green('✅ Webhooks exported successfully!')}`);
         console.log('');
         console.log(`${chalk.bold('File:')} ${filename}`);
         console.log(`${chalk.bold('Webhooks:')} ${webhooks.length}`);
@@ -51,7 +51,7 @@ export async function importAction(filename, options) {
             console.log(JSON.stringify({ webhooks, metadata }, null, 2));
             return;
         }
-        console.log('\n' + chalk.green('✅ Webhooks loaded successfully!'));
+        console.log(`\n${chalk.green('✅ Webhooks loaded successfully!')}`);
         console.log('');
         console.log(`${chalk.bold('Source:')} ${filename}`);
         console.log(`${chalk.bold('Webhooks:')} ${webhooks.length}`);
@@ -61,7 +61,7 @@ export async function importAction(filename, options) {
             console.log(chalk.yellow('No webhooks found in the export file.'));
             return;
         }
-        console.log('\n' + chalk.bold('Webhooks to import:'));
+        console.log(`\n${chalk.bold('Webhooks to import:')}`);
         console.log(chalk.gray('─'.repeat(80)));
         webhooks.forEach((webhook, index) => {
             const status = options.dryRun ? chalk.gray('pending') : chalk.yellow('will create');
@@ -105,14 +105,14 @@ export async function importAction(filename, options) {
         }
         const successful = results.filter((result) => result.success).length;
         const failed = results.filter((result) => !result.success).length;
-        console.log('\n' + chalk.bold('Import Results:'));
+        console.log(`\n${chalk.bold('Import Results:')}`);
         console.log(chalk.gray('─'.repeat(50)));
         console.log(`${chalk.green('Successful:')} ${successful}`);
         if (failed > 0) {
             console.log(`${chalk.red('Failed:')} ${failed}`);
         }
         if (successful > 0) {
-            console.log('\n' + chalk.green('✅ Successfully created webhooks:'));
+            console.log(`\n${chalk.green('✅ Successfully created webhooks:')}`);
             results
                 .filter((result) => result.success)
                 .forEach((result, index) => {
@@ -120,7 +120,7 @@ export async function importAction(filename, options) {
             });
         }
         if (failed > 0) {
-            console.log('\n' + chalk.red('❌ Failed webhooks:'));
+            console.log(`\n${chalk.red('❌ Failed webhooks:')}`);
             results
                 .filter((result) => !result.success)
                 .forEach((result, index) => {
@@ -206,7 +206,7 @@ export async function createAction(options) {
             config.webhookSecrets[webhook.id] = webhook.attributes.secret;
             await configManager.save(config);
         }
-        console.log('\n' + chalk.green('✓ Webhook created successfully!'));
+        console.log(`\n${chalk.green('✓ Webhook created successfully!')}`);
         console.log('');
         console.log(chalk.bold('ID:'), webhook.id);
         console.log(chalk.bold('URL:'), webhook.attributes.url);
@@ -276,7 +276,7 @@ export async function listAction(options) {
             console.log(JSON.stringify(filteredWebhooks, null, 2));
             return;
         }
-        console.log('\n' + chalk.bold('Webhooks'));
+        console.log(`\n${chalk.bold('Webhooks')}`);
         console.log(chalk.gray('─'.repeat(95)));
         const table = new Table({
             head: [chalk.bold('ID'), chalk.bold('URL'), chalk.bold('Status'), chalk.bold('Events')],
@@ -289,7 +289,7 @@ export async function listAction(options) {
         filteredWebhooks.forEach((webhook) => {
             const id = webhook.id.substring(0, 12) + (webhook.id.length > 12 ? '...' : '');
             const url = webhook.attributes.url.length > 30
-                ? webhook.attributes.url.substring(0, 27) + '...'
+                ? `${webhook.attributes.url.substring(0, 27)}...`
                 : webhook.attributes.url;
             const events = webhook.attributes.events.length > 1
                 ? `${webhook.attributes.events[0]} +${webhook.attributes.events.length - 1} more`
@@ -415,7 +415,7 @@ export async function showAction(id) {
         spinner.start('Fetching webhook details...');
         const webhook = await createApiClient(config).getWebhook(id);
         spinner.succeed('Webhook details loaded');
-        console.log('\n' + chalk.bold('Webhook Details'));
+        console.log(`\n${chalk.bold('Webhook Details')}`);
         console.log('═'.repeat(50));
         console.log(chalk.bold('ID:'), webhook.id);
         console.log(chalk.bold('URL:'), webhook.attributes.url);

package/dist/commands/webhooks/helpers.js

@@ -1,28 +1,13 @@
 import chalk from 'chalk';
-import ApiClient from '../../services/api/client.js';
-import ConfigManager from '../../services/config/manager.js';
-import Spinner from '../../utils/spinner.js';
-import { CommandError } from '../../utils/errors.js';
+import { createCommandContext, createApiClient as createSharedApiClient, failCommand, loadCommandConfig, } from '../shared/runtime.js';
 export function createWebhooksContext() {
-    return {
-        spinner: new Spinner(),
-        configManager: new ConfigManager(),
-    };
+    return createCommandContext();
 }
 export async function loadWebhooksConfig(spinner, configManager) {
-    spinner.start('Loading configuration...');
-    const config = await configManager.load();
-    if (!config) {
-        spinner.fail('No configuration found');
-        console.log(chalk.yellow('No PayMongo configuration found.'));
-        console.log(chalk.gray("Run 'paymongo init' to set up your project first."));
-        return null;
-    }
-    spinner.succeed('Configuration loaded');
-    return config;
+    return loadCommandConfig(spinner, configManager);
 }
 export function createApiClient(config) {
-    return new ApiClient({ config });
+    return createSharedApiClient(config);
 }
 export function getWebhookStatusColor(status) {
     switch (status) {
@@ -35,8 +20,5 @@ export function getWebhookStatusColor(status) {
     }
 }
 export function handleWebhooksError(prefix, spinner, error) {
-    spinner.stop();
-    const err = error;
-    console.error(chalk.red(prefix), err.message);
-    throw new CommandError();
+    return failCommand(prefix, error, spinner);
 }

package/dist/commands/webhooks.js

@@ -37,5 +37,5 @@ const command = new Command('webhooks')
     .description('Show webhook details')
     .argument('<id>', 'Webhook ID to show')
     .action(async (id) => showAction(id)));
-export { exportAction, importAction, createAction, listAction, disableAction, enableAction, deleteAction, showAction, };
+export { createAction, deleteAction, disableAction, enableAction, exportAction, importAction, listAction, showAction, };
 export default command;

package/dist/index.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
+import { createRequire } from 'node:module';
 import chalk from 'chalk';
-import { createRequire } from 'module';
+import { Command } from 'commander';
 import { CommandError } from './utils/errors.js';
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
+const uncaughtExceptionHandlerKey = Symbol.for('paymongo.cli.uncaughtExceptionHandler');
+const unhandledRejectionHandlerKey = Symbol.for('paymongo.cli.unhandledRejectionHandler');
+const globalHandlers = globalThis;
 const program = new Command();
 program
     .name('paymongo')
@@ -12,6 +15,15 @@ program
     .version(version)
     .option('--no-rate-limit', 'Disable rate limiting for this command')
     .showHelpAfterError('(add --help for additional information)');
+program.hook('preAction', (actionCommand) => {
+    const options = actionCommand.optsWithGlobals();
+    if (options.rateLimit === false) {
+        process.env.PAYMONGO_DISABLE_RATE_LIMIT = '1';
+    }
+    else {
+        delete process.env.PAYMONGO_DISABLE_RATE_LIMIT;
+    }
+});
 program.addCommand(await import('./commands/init.js').then((m) => m.default));
 program.addCommand((await import('./commands/dev.js')).command);
 program.addCommand((await import('./commands/login.js')).command);
@@ -73,18 +85,24 @@ EXAMPLES
 
 For more information, visit: https://github.com/leodyversemilla07/paymongo-cli
 `);
-process.on('uncaughtException', (error) => {
-    if (error instanceof CommandError) {
+if (!globalHandlers[uncaughtExceptionHandlerKey]) {
+    globalHandlers[uncaughtExceptionHandlerKey] = (error) => {
+        if (error instanceof CommandError) {
+            process.exit(1);
+        }
+        console.error(chalk.red('An unexpected error occurred:'), error.message);
         process.exit(1);
-    }
-    console.error(chalk.red('An unexpected error occurred:'), error.message);
-    process.exit(1);
-});
-process.on('unhandledRejection', (reason) => {
-    if (reason instanceof CommandError) {
+    };
+    process.on('uncaughtException', globalHandlers[uncaughtExceptionHandlerKey]);
+}
+if (!globalHandlers[unhandledRejectionHandlerKey]) {
+    globalHandlers[unhandledRejectionHandlerKey] = (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);
-    }
-    console.error(chalk.red('An unexpected error occurred:'), reason instanceof Error ? reason.message : String(reason));
-    process.exit(1);
-});
+    };
+    process.on('unhandledRejection', globalHandlers[unhandledRejectionHandlerKey]);
+}
 program.parse();

package/dist/services/analytics/service.js

@@ -1,6 +1,6 @@
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 import Logger from '../../utils/logger.js';
 export class AnalyticsService {
     events = [];

package/dist/services/api/client.js

@@ -1,8 +1,8 @@
 import { request } from 'undici';
-import { NetworkError, ApiKeyError, PayMongoError, withRetry } from '../../utils/errors.js';
 import Cache from '../../utils/cache.js';
+import { CACHE_TTL, CLI_VERSION, PAYMONGO_API_BASE, RATE_LIMIT_DEFAULT_MAX, RATE_LIMIT_ENV_MULTIPLIER, RATE_LIMIT_PAYMENTS_MAX, RATE_LIMIT_REFUNDS_MAX, RATE_LIMIT_WEBHOOKS_MAX, RATE_LIMIT_WINDOW_MS, REQUEST_TIMEOUT, } from '../../utils/constants.js';
+import { ApiKeyError, NetworkError, PayMongoError, withRetry } from '../../utils/errors.js';
 import RateLimiter from './rate-limiter.js';
-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;
@@ -19,7 +19,10 @@ export class ApiClient {
             'User-Agent': `paymongo-cli/${CLI_VERSION}`,
         };
         this.cache = new Cache({ ttl: CACHE_TTL });
-        const rateLimitEnabled = options.enableRateLimiting !== false && this.config.rateLimiting?.enabled !== false;
+        const globalRateLimitDisabled = process.env.PAYMONGO_DISABLE_RATE_LIMIT === '1';
+        const rateLimitEnabled = options.enableRateLimiting !== false &&
+            !globalRateLimitDisabled &&
+            this.config.rateLimiting?.enabled !== false;
         if (rateLimitEnabled) {
             const rateLimitConfig = options.rateLimitConfig || this.getDefaultRateLimitConfig();
             if (this.config.rateLimiting) {
@@ -106,6 +109,7 @@ export class ApiClient {
         }
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        timeoutId.unref?.();
         try {
             const response = await request(url.toString(), {
                 method,
@@ -120,7 +124,7 @@ export class ApiClient {
             }
             let data;
             const contentType = response.headers['content-type'];
-            if (contentType && contentType.includes('application/json')) {
+            if (contentType?.includes('application/json')) {
                 data = await response.body.json();
             }
             else {

package/dist/services/config/manager.js

@@ -1,8 +1,8 @@
-import * as fs from 'fs';
-import * as path from 'path';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { cosmiconfig } from 'cosmiconfig';
-import { ConfigError, ValidationError } from '../../utils/errors.js';
 import { validateConfig as zodValidateConfig } from '../../types/schemas.js';
+import { ConfigError, ValidationError } from '../../utils/errors.js';
 const CONFIG_FILE_NAME = '.paymongo';
 export class ConfigManager {
     explorer = cosmiconfig('paymongo');

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

@@ -1,7 +1,7 @@
-import fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import { execSync } from 'child_process';
+import { execSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
 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');

package/dist/services/dev/server.js

@@ -1,8 +1,8 @@
-import * as http from 'http';
-import * as crypto from 'crypto';
+import * as crypto from 'node:crypto';
+import * as http from 'node:http';
 import chalk from 'chalk';
-import { AnalyticsService } from '../analytics/service.js';
 import Logger from '../../utils/logger.js';
+import { AnalyticsService } from '../analytics/service.js';
 export class DevServer {
     server;
     port;
@@ -147,9 +147,7 @@ export class DevServer {
                     break;
                 }
             }
-            catch (_error) {
-                continue;
-            }
+            catch (_error) { }
         }
         if (isValid) {
             this.logger.success('Signature verified successfully');

package/dist/services/dev/session.js

@@ -0,0 +1,353 @@
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import chalk from 'chalk';
+import { CommandError, withRetry } from '../../utils/errors.js';
+import ApiClient from '../api/client.js';
+import { DevProcessManager } from './process-manager.js';
+import DevServer from './server.js';
+export class DevSessionService {
+    spinner;
+    configManager;
+    onMissingConfig;
+    constructor({ spinner, configManager, onMissingConfig }) {
+        this.spinner = spinner;
+        this.configManager = configManager;
+        this.onMissingConfig = onMissingConfig;
+    }
+    async run(options) {
+        let tunnel;
+        if (await this.handleDetachedStart(options)) {
+            return;
+        }
+        try {
+            const config = await this.loadConfig();
+            if (!config) {
+                return;
+            }
+            const port = this.getPort(options);
+            tunnel = await this.createTunnelWithStatus(port, options.ngrokToken);
+            const tunnelUrl = tunnel.url() ?? '';
+            const devServer = new DevServer(port, config);
+            await devServer.start();
+            await this.cleanupStaleWebhooks(config);
+            const { webhookId, webhookUrl } = await this.registerWebhookIfNeeded(config, options, tunnelUrl);
+            const { localWebhookUrl, externalWebhookUrl } = this.printStatus(config, options, port, tunnelUrl, webhookId);
+            await this.saveState(config, options, port, tunnelUrl, webhookId, webhookUrl || externalWebhookUrl, localWebhookUrl);
+            const cleanup = this.createCleanupHandler({
+                config,
+                devServer,
+                tunnel,
+                webhookId,
+            });
+            process.once('SIGINT', () => {
+                void cleanup();
+            });
+            process.once('SIGTERM', () => {
+                void cleanup();
+            });
+            await new Promise(() => { });
+        }
+        catch (error) {
+            this.spinner.stop();
+            const err = error;
+            this.printTunnelError(err);
+            await this.cleanupAfterStartupFailure(tunnel);
+            throw new CommandError();
+        }
+    }
+    getPort(options) {
+        return parseInt(options.port || '3000', 10);
+    }
+    getEvents(options) {
+        return (options.events || 'payment.paid,payment.failed').split(',');
+    }
+    getProjectSlug(projectName) {
+        return projectName.toLowerCase().replace(/[^a-z0-9]/g, '-');
+    }
+    buildWebhookUrls(projectName, port, tunnelUrl) {
+        const projectSlug = this.getProjectSlug(projectName);
+        return {
+            localWebhookUrl: `http://localhost:${port}/webhook/${projectSlug}`,
+            externalWebhookUrl: `${tunnelUrl}/webhook/${projectSlug}`,
+        };
+    }
+    async handleDetachedStart(options) {
+        if (!options.detach) {
+            return false;
+        }
+        const existingState = await DevProcessManager.loadState();
+        if (existingState && DevProcessManager.isProcessRunning(existingState.pid)) {
+            console.log(chalk.yellow('⚠️  Dev server is already running in background'));
+            console.log('');
+            console.log(chalk.bold('Status:'));
+            console.log(chalk.gray('  PID:'), existingState.pid);
+            console.log(chalk.gray('  Port:'), existingState.port);
+            console.log(chalk.gray('  Tunnel:'), existingState.tunnelUrl);
+            console.log(chalk.gray('  Uptime:'), DevProcessManager.formatUptime(existingState.startedAt));
+            console.log('');
+            console.log(chalk.gray('Use "paymongo dev stop" to stop the server first.'));
+            return true;
+        }
+        const entryScript = process.argv[1];
+        if (!entryScript) {
+            throw new Error('Unable to determine the current CLI entrypoint for detached mode');
+        }
+        const args = [entryScript, 'dev', '--port', options.port || '3000'];
+        if (options.noRegister) {
+            args.push('--no-register');
+        }
+        if (options.events) {
+            args.push('--events', options.events);
+        }
+        if (options.ngrokToken) {
+            args.push('--ngrok-token', options.ngrokToken);
+        }
+        const logFile = await DevProcessManager.getLogFile();
+        const out = fs.openSync(logFile, 'a');
+        const err = fs.openSync(logFile, 'a');
+        const child = spawn(process.execPath, args, {
+            detached: true,
+            stdio: ['ignore', out, err],
+            cwd: process.cwd(),
+            env: { ...process.env, FORCE_COLOR: '1' },
+        });
+        child.unref();
+        console.log(chalk.green('✓'), 'Dev server starting in background...');
+        console.log(chalk.gray('  PID:'), child.pid);
+        console.log(chalk.gray('  Logs:'), logFile);
+        console.log('');
+        console.log(chalk.gray('Use "paymongo dev status" to check server status'));
+        console.log(chalk.gray('Use "paymongo dev stop" to stop the server'));
+        console.log(chalk.gray('Use "paymongo dev logs" to view server logs'));
+        await new Promise((resolve) => {
+            setTimeout(resolve, 500);
+        });
+        return true;
+    }
+    async loadConfig() {
+        this.spinner.start('Loading configuration...');
+        const config = await this.configManager.load();
+        if (!config) {
+            this.spinner.fail('No configuration found');
+            this.onMissingConfig?.();
+            return null;
+        }
+        this.spinner.succeed('Configuration loaded');
+        return config;
+    }
+    async createTunnelWithStatus(port, ngrokToken) {
+        this.spinner.start('Creating tunnel...');
+        const tunnel = await this.createTunnel(port, ngrokToken);
+        this.spinner.succeed('Tunnel created');
+        return tunnel;
+    }
+    async createTunnel(port, ngrokToken) {
+        const { default: ngrok } = await import('@ngrok/ngrok');
+        return withRetry(async () => {
+            const authtoken = ngrokToken || process.env.NGROK_AUTHTOKEN;
+            if (!authtoken) {
+                throw new Error('ngrok authtoken not found. Please either:\n' +
+                    '  1. Set NGROK_AUTHTOKEN environment variable, or\n' +
+                    '  2. Use --ngrok-token option: paymongo dev --ngrok-token YOUR_TOKEN\n' +
+                    '  Get your token from: https://dashboard.ngrok.com/get-started/your-authtoken');
+            }
+            const tunnel = await ngrok.forward({
+                addr: port,
+                authtoken,
+            });
+            return tunnel;
+        }, {
+            maxRetries: 3,
+            delayMs: 2000,
+            retryCondition: (error) => {
+                return (error.message.includes('connection') ||
+                    error.message.includes('timeout') ||
+                    error.message.includes('tunnel') ||
+                    error.message.includes('ngrok'));
+            },
+        });
+    }
+    async cleanupStaleWebhooks(config) {
+        if (!config.registeredWebhooks || config.registeredWebhooks.length === 0) {
+            return;
+        }
+        this.spinner.start('Cleaning up stale webhooks...');
+        const apiClient = new ApiClient({ config });
+        let cleanedCount = 0;
+        for (const webhook of config.registeredWebhooks) {
+            try {
+                await apiClient.disableWebhook(webhook.id);
+                cleanedCount++;
+            }
+            catch {
+            }
+        }
+        config.registeredWebhooks = [];
+        await this.configManager.save(config);
+        if (cleanedCount > 0) {
+            this.spinner.succeed(`Cleaned up ${cleanedCount} stale webhook(s)`);
+        }
+        else {
+            this.spinner.succeed('No stale webhooks to clean up');
+        }
+    }
+    async registerWebhookIfNeeded(config, options, tunnelUrl) {
+        const shouldRegister = !options.noRegister && config.dev.autoRegisterWebhook !== false;
+        if (!shouldRegister) {
+            return {};
+        }
+        this.spinner.start('Registering webhook...');
+        const events = this.getEvents(options);
+        const { externalWebhookUrl } = this.buildWebhookUrls(config.projectName, this.getPort(options), tunnelUrl);
+        try {
+            const webhook = (await new ApiClient({ config }).createWebhook(externalWebhookUrl, events));
+            await this.persistRegisteredWebhook(config, webhook, externalWebhookUrl);
+            if (webhook.attributes?.secret) {
+                this.spinner.succeed(`Webhook registered: ${webhook.id} (with signature verification)`);
+            }
+            else {
+                this.spinner.succeed(`Webhook registered: ${webhook.id}`);
+            }
+            return {
+                webhookId: webhook.id,
+                webhookUrl: externalWebhookUrl,
+            };
+        }
+        catch (error) {
+            const err = error;
+            this.spinner.warn('Webhook registration failed - server will start without webhook');
+            this.printWebhookRegistrationFailure(err, externalWebhookUrl, config);
+            return {
+                webhookUrl: externalWebhookUrl,
+            };
+        }
+    }
+    async persistRegisteredWebhook(config, webhook, webhookUrl) {
+        if (webhook.attributes?.secret) {
+            config.webhookSecrets = config.webhookSecrets || {};
+            config.webhookSecrets[webhook.id] = webhook.attributes.secret;
+        }
+        config.registeredWebhooks = config.registeredWebhooks || [];
+        config.registeredWebhooks.push({
+            id: webhook.id,
+            url: webhookUrl,
+            createdAt: Date.now(),
+        });
+        await this.configManager.save(config);
+    }
+    printWebhookRegistrationFailure(error, webhookUrl, config) {
+        console.log(chalk.yellow('⚠️'), 'Webhook registration failed:', error.message);
+        console.log('');
+        console.log(chalk.blue('ℹ️'), 'You can still test webhooks manually:');
+        console.log(chalk.gray(`   Webhook URL: ${webhookUrl}`));
+        console.log(chalk.gray('   Copy this URL to your PayMongo dashboard'));
+        if (config.dev.verifyWebhookSignatures) {
+            console.log(chalk.gray('   Signature verification is currently enabled'));
+            console.log(chalk.gray('   For manual unsigned testing, run: paymongo config set dev.verifySignatures false'));
+        }
+        console.log('');
+        if (error.message.includes('API key') || error.message.includes('unauthorized')) {
+            console.log(chalk.yellow('💡 To fix webhook registration:'));
+            console.log(chalk.gray('   1. Run "paymongo login" to update your API keys'));
+            console.log(chalk.gray('   2. Restart the development server'));
+        }
+    }
+    printStatus(config, options, port, tunnelUrl, webhookId) {
+        const { localWebhookUrl, externalWebhookUrl } = this.buildWebhookUrls(config.projectName, port, tunnelUrl);
+        console.log(`\n${chalk.green('🚀 PayMongo Development Server')}`);
+        console.log('');
+        console.log(chalk.bold('URLs:'));
+        console.log(chalk.gray('  ├─'), chalk.cyan('External (PayMongo sends here):'));
+        console.log(chalk.gray('  │  '), chalk.yellow(externalWebhookUrl));
+        console.log(chalk.gray('  │'));
+        console.log(chalk.gray('  └─'), chalk.cyan('Local (Your server receives here):'));
+        console.log(chalk.gray('     '), chalk.green(localWebhookUrl));
+        console.log('');
+        console.log(chalk.bold('Forwarding:'));
+        console.log(chalk.gray('  '), `${chalk.yellow(tunnelUrl)} ${chalk.gray('→')} ${chalk.green(`http://localhost:${port}`)}`);
+        console.log('');
+        if (webhookId) {
+            console.log(chalk.bold('Webhook ID:'), chalk.gray(webhookId));
+        }
+        console.log(chalk.bold('Events:'), this.getEvents(options).join(', '));
+        console.log('');
+        console.log(chalk.gray('💡 Tip: Use the External URL in PayMongo dashboard, requests will forward to your local server'));
+        console.log(chalk.gray('Press Ctrl+C to stop'));
+        return { localWebhookUrl, externalWebhookUrl };
+    }
+    async saveState(config, options, port, tunnelUrl, webhookId, webhookUrl, localUrl) {
+        await DevProcessManager.saveState({
+            pid: process.pid,
+            port,
+            tunnelUrl,
+            webhookId,
+            webhookUrl,
+            localUrl,
+            events: this.getEvents(options),
+            startedAt: Date.now(),
+            projectName: config.projectName,
+        });
+    }
+    createCleanupHandler({ config, devServer, tunnel, webhookId, }) {
+        let cleanedUp = false;
+        return async () => {
+            if (cleanedUp) {
+                return;
+            }
+            cleanedUp = true;
+            console.log(`\n${chalk.yellow('Shutting down...')}`);
+            await DevProcessManager.clearState();
+            try {
+                if (tunnel) {
+                    await tunnel.close();
+                    console.log(chalk.yellow('✓'), 'Tunnel closed');
+                }
+                await devServer.stop();
+                if (webhookId) {
+                    this.spinner.start('Cleaning up webhook...');
+                    await new ApiClient({ config }).disableWebhook(webhookId);
+                    if (config.registeredWebhooks) {
+                        config.registeredWebhooks = config.registeredWebhooks.filter((webhook) => {
+                            return webhook.id !== webhookId;
+                        });
+                        if (config.webhookSecrets) {
+                            delete config.webhookSecrets[webhookId];
+                        }
+                        await this.configManager.save(config);
+                    }
+                    this.spinner.succeed('Webhook disabled');
+                }
+            }
+            catch (error) {
+                console.error(chalk.red('Error during cleanup:'), error.message);
+                console.log(chalk.yellow('⚠️'), 'Some cleanup tasks may not have completed');
+            }
+            process.exit(0);
+        };
+    }
+    async cleanupAfterStartupFailure(tunnel) {
+        await DevProcessManager.clearState();
+        try {
+            if (tunnel) {
+                await tunnel.close();
+            }
+        }
+        catch {
+        }
+    }
+    printTunnelError(error) {
+        if (!error.message.includes('ngrok') && !error.message.includes('tunnel')) {
+            return;
+        }
+        console.error(chalk.red('❌ Failed to create tunnel:'), error.message);
+        console.log('');
+        console.log(chalk.yellow('💡 Troubleshooting suggestions:'));
+        console.log(chalk.gray('• Check your internet connection'));
+        console.log(chalk.gray('• Make sure ngrok is not blocked by firewall/antivirus'));
+        console.log(chalk.gray('• Set up ngrok authentication: export NGROK_AUTHTOKEN=your_token'));
+        console.log(chalk.gray('• Get your authtoken from: https://dashboard.ngrok.com/get-started/your-authtoken'));
+        console.log(chalk.gray('• Try a different port: paymongo dev --port 3001'));
+        console.log(chalk.gray('• Visit https://ngrok.com for status updates'));
+    }
+}
+export default DevSessionService;