paymongo-cli 1.4.12 → 1.4.13

package/dist/commands/config/actions.js

@@ -1,6 +1,6 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import chalk from 'chalk';
-import * as fs from 'fs';
-import * as path from 'path';
 import { CommandError } from '../../utils/errors.js';
 import { checkConfigConflicts, createConfigContext, handleCommandFailure, loadRequiredConfig, setConfigValue, validateImportedConfig, validateImportedConfigWithSchema, } from './helpers.js';
 export async function showAction(options) {
@@ -19,7 +19,7 @@ export async function showAction(options) {
             console.log(JSON.stringify(config, null, 2));
             return;
         }
-        console.log('\n' + chalk.bold('Configuration (.paymongo)'));
+        console.log(`\n${chalk.bold('Configuration (.paymongo)')}`);
         console.log('');
         console.log(chalk.bold('Project:'), config.projectName);
         console.log(chalk.bold('Environment:'), config.environment);
@@ -32,6 +32,10 @@ export async function showAction(options) {
         console.log(chalk.bold('Auto Register Webhook:'), config.dev.autoRegisterWebhook ? 'Yes' : 'No');
         console.log(chalk.bold('Verify Webhook Signatures:'), config.dev.verifyWebhookSignatures ? 'Yes' : 'No');
         console.log('');
+        if (config.analytics) {
+            console.log(chalk.bold('Analytics:'), config.analytics.enabled ? 'Enabled' : 'Disabled');
+            console.log('');
+        }
         if (config.rateLimiting) {
             console.log(chalk.bold('Rate Limiting:'));
             console.log(chalk.bold('  Enabled:'), config.rateLimiting.enabled ? chalk.green('Yes') : chalk.red('No'));
@@ -190,7 +194,9 @@ export async function importAction(filePath, options) {
         if (validationErrors.length > 0) {
             spinner.fail('Invalid configuration');
             console.error(chalk.red('❌ Configuration validation failed:'));
-            validationErrors.forEach((err) => console.error(chalk.gray(`  • ${err}`)));
+            validationErrors.forEach((err) => {
+                console.error(chalk.gray(`  • ${err}`));
+            });
             throw new CommandError();
         }
         spinner.succeed('Configuration validated');
@@ -201,7 +207,9 @@ export async function importAction(filePath, options) {
             if (conflicts.length > 0) {
                 spinner.stop();
                 console.log(chalk.yellow('⚠️  Configuration conflicts detected:'));
-                conflicts.forEach((conflict) => console.log(chalk.gray(`  • ${conflict}`)));
+                conflicts.forEach((conflict) => {
+                    console.log(chalk.gray(`  • ${conflict}`));
+                });
                 console.log('');
                 console.log(chalk.bold('Use --force to overwrite existing configuration'));
                 throw new CommandError();

package/dist/commands/config/analytics.js

@@ -0,0 +1,75 @@
+import chalk from 'chalk';
+import { CommandError } from '../../utils/errors.js';
+import { createConfigContext, ensureAnalyticsConfig, loadRequiredConfig } from './helpers.js';
+export async function analyticsEnableAction() {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        const config = await loadRequiredConfig(spinner, configManager);
+        if (!config) {
+            return;
+        }
+        ensureAnalyticsConfig(config).enabled = true;
+        spinner.start('Enabling analytics...');
+        await configManager.save(config);
+        spinner.succeed('Analytics enabled');
+        console.log(chalk.green('✓ Analytics enabled'));
+        console.log(chalk.gray('Webhook events will now be tracked locally on this machine'));
+    }
+    catch (error) {
+        spinner.stop();
+        const err = error;
+        console.error(chalk.red('❌ Failed to enable analytics:'), err.message);
+        throw new CommandError();
+    }
+}
+export async function analyticsDisableAction() {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        const config = await loadRequiredConfig(spinner, configManager);
+        if (!config) {
+            return;
+        }
+        ensureAnalyticsConfig(config).enabled = false;
+        spinner.start('Disabling analytics...');
+        await configManager.save(config);
+        spinner.succeed('Analytics disabled');
+        console.log(chalk.green('✓ Analytics disabled'));
+        console.log(chalk.gray('Existing analytics data remains local until you remove it manually'));
+    }
+    catch (error) {
+        spinner.stop();
+        const err = error;
+        console.error(chalk.red('❌ Failed to disable analytics:'), err.message);
+        throw new CommandError();
+    }
+}
+export async function analyticsStatusAction() {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        const config = await loadRequiredConfig(spinner, configManager);
+        if (!config) {
+            return;
+        }
+        console.log(`\n${chalk.bold('Analytics Status')}`);
+        console.log('');
+        if (!config.analytics?.enabled) {
+            console.log(chalk.yellow('Status: Disabled'));
+            console.log(chalk.gray('Webhook analytics are currently opt-out for this project'));
+            console.log('');
+            console.log(chalk.gray("Run 'paymongo config analytics enable' to enable"));
+            return;
+        }
+        console.log(chalk.green('Status: Enabled'));
+        console.log(chalk.gray('Webhook analytics are stored locally and never sent externally'));
+        console.log('');
+        console.log(chalk.gray('Commands:'));
+        console.log(chalk.gray("• 'paymongo config analytics disable' - Disable analytics"));
+        console.log(chalk.gray("• 'paymongo config show' - View current analytics setting"));
+    }
+    catch (error) {
+        spinner.stop();
+        const err = error;
+        console.error(chalk.red('❌ Failed to check analytics status:'), err.message);
+        throw new CommandError();
+    }
+}

package/dist/commands/config/helpers.js

@@ -1,8 +1,5 @@
-import chalk from 'chalk';
 import { validateConfig as zodValidateConfig } from '../../types/schemas.js';
-import ConfigManager from '../../services/config/manager.js';
-import Spinner from '../../utils/spinner.js';
-import { CommandError } from '../../utils/errors.js';
+import { createCommandContext, failCommand, loadCommandConfig } from '../shared/runtime.js';
 export const CONFIG_KEY_MAPPINGS = {
     'project.name': 'projectName',
     'webhook.url': 'webhooks.url',
@@ -10,35 +7,19 @@ export const CONFIG_KEY_MAPPINGS = {
     'dev.port': 'dev.port',
     'dev.autoRegister': 'dev.autoRegisterWebhook',
     'dev.verifySignatures': 'dev.verifyWebhookSignatures',
+    'analytics.enabled': 'analytics.enabled',
     'rateLimit.enabled': 'rateLimiting.enabled',
     'rateLimit.maxRequests': 'rateLimiting.maxRequests',
     'rateLimit.windowMs': 'rateLimiting.windowMs',
 };
 export function createConfigContext() {
-    return {
-        spinner: new Spinner(),
-        configManager: new ConfigManager(),
-    };
-}
-export function showNoConfigMessage(message = "Run 'paymongo init' to set up your project first.") {
-    console.log(chalk.yellow('No PayMongo configuration found.'));
-    console.log(chalk.gray(message));
+    return createCommandContext();
 }
 export async function loadRequiredConfig(spinner, configManager, loadingText = 'Loading configuration...') {
-    spinner.start(loadingText);
-    const config = await configManager.load();
-    if (!config) {
-        spinner.fail('No configuration found');
-        showNoConfigMessage();
-        return null;
-    }
-    spinner.succeed('Configuration loaded');
-    return config;
+    return loadCommandConfig(spinner, configManager, loadingText);
 }
 export function handleCommandFailure(prefix, error) {
-    const err = error;
-    console.error(chalk.red(prefix), err.message);
-    throw new CommandError();
+    return failCommand(prefix, error);
 }
 export function validateImportedConfig(config) {
     if (typeof config !== 'object' || config === null) {
@@ -135,7 +116,7 @@ export function coerceConfigValue(value) {
     if (value === 'false') {
         return false;
     }
-    if (!isNaN(Number(value))) {
+    if (!Number.isNaN(Number(value))) {
         return Number(value);
     }
     return value;
@@ -151,3 +132,11 @@ export function ensureRateLimitingConfig(config) {
     }
     return config.rateLimiting;
 }
+export function ensureAnalyticsConfig(config) {
+    if (!config.analytics) {
+        config.analytics = {
+            enabled: false,
+        };
+    }
+    return config.analytics;
+}

package/dist/commands/config/rate-limit.js

@@ -3,7 +3,7 @@ import { CommandError } from '../../utils/errors.js';
 import { createConfigContext, ensureRateLimitingConfig, loadRequiredConfig } from './helpers.js';
 function parsePositiveInt(value, message) {
     const parsed = parseInt(value, 10);
-    if (isNaN(parsed) || parsed < 1) {
+    if (Number.isNaN(parsed) || parsed < 1) {
         console.error(chalk.red(message));
         throw new CommandError();
     }
@@ -102,9 +102,9 @@ export async function rateLimitStatusAction() {
         if (!config) {
             return;
         }
-        console.log('\n' + chalk.bold('Rate Limiting Status'));
+        console.log(`\n${chalk.bold('Rate Limiting Status')}`);
         console.log('');
-        if (!config.rateLimiting || !config.rateLimiting.enabled) {
+        if (!config.rateLimiting?.enabled) {
             console.log(chalk.yellow('Status: Disabled'));
             console.log(chalk.gray('Rate limiting is not currently active'));
             console.log('');

package/dist/commands/config.js

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import { backupAction, importAction, resetAction, setAction, showAction, } from './config/actions.js';
+import { analyticsDisableAction, analyticsEnableAction, analyticsStatusAction, } from './config/analytics.js';
 import { rateLimitDisableAction, rateLimitEnableAction, rateLimitSetMaxRequestsAction, rateLimitSetWindowAction, rateLimitStatusAction, } from './config/rate-limit.js';
 const command = new Command('config');
 command
@@ -23,6 +24,11 @@ command
     .arguments('<file>')
     .option('-f, --force', 'Overwrite existing configuration without confirmation')
     .action(importAction))
+    .addCommand(new Command('analytics')
+    .description('Configure local webhook analytics')
+    .addCommand(new Command('enable').description('Enable analytics').action(analyticsEnableAction))
+    .addCommand(new Command('disable').description('Disable analytics').action(analyticsDisableAction))
+    .addCommand(new Command('status').description('Show analytics status').action(analyticsStatusAction)))
     .addCommand(new Command('rate-limit')
     .description('Configure rate limiting settings')
     .addCommand(new Command('enable').description('Enable rate limiting').action(rateLimitEnableAction))
@@ -38,5 +44,5 @@ command
     .addCommand(new Command('status')
     .description('Show current rate limiting settings')
     .action(rateLimitStatusAction)));
-export { showAction, setAction, backupAction, resetAction, importAction, rateLimitEnableAction, rateLimitDisableAction, rateLimitSetMaxRequestsAction, rateLimitSetWindowAction, rateLimitStatusAction, };
+export { analyticsDisableAction, analyticsEnableAction, analyticsStatusAction, backupAction, importAction, rateLimitDisableAction, rateLimitEnableAction, rateLimitSetMaxRequestsAction, rateLimitSetWindowAction, rateLimitStatusAction, resetAction, setAction, showAction, };
 export default command;

package/dist/commands/dev/logs.js

@@ -1,6 +1,6 @@
-import { Command } from 'commander';
-import * as fs from 'fs';
+import * as fs from 'node:fs';
 import chalk from 'chalk';
+import { Command } from 'commander';
 import { DevProcessManager } from '../../services/dev/process-manager.js';
 const logsCommand = new Command('logs')
     .description('View dev server logs')
@@ -14,7 +14,7 @@ const logsCommand = new Command('logs')
         return;
     }
     const logFile = await DevProcessManager.getLogFile();
-    const lines = await DevProcessManager.readLogs(parseInt(options.lines));
+    const lines = await DevProcessManager.readLogs(parseInt(options.lines, 10));
     if (lines.length === 0) {
         console.log(chalk.yellow('No logs available.'));
         console.log(chalk.gray('Log file:'), logFile);
@@ -24,11 +24,18 @@ const logsCommand = new Command('logs')
     console.log(chalk.gray(`(Last ${lines.length} lines from ${logFile})`));
     console.log(chalk.gray('─'.repeat(60)));
     console.log('');
-    lines.forEach((line) => console.log(line));
+    lines.forEach((line) => {
+        console.log(line);
+    });
     if (options.follow) {
         console.log('');
         console.log(chalk.gray('Following logs... Press Ctrl+C to stop'));
         let lastSize = fs.statSync(logFile).size;
+        const stopWatching = () => {
+            fs.unwatchFile(logFile);
+            process.removeListener('SIGINT', stopWatching);
+            process.removeListener('SIGTERM', stopWatching);
+        };
         fs.watchFile(logFile, { interval: 500 }, () => {
             const newSize = fs.statSync(logFile).size;
             if (newSize > lastSize) {
@@ -40,6 +47,8 @@ const logsCommand = new Command('logs')
                 lastSize = newSize;
             }
         });
+        process.on('SIGINT', stopWatching);
+        process.on('SIGTERM', stopWatching);
         await new Promise(() => { });
     }
 });

package/dist/commands/dev/status.js

@@ -1,5 +1,5 @@
-import { Command } from 'commander';
 import chalk from 'chalk';
+import { Command } from 'commander';
 import { DevProcessManager } from '../../services/dev/process-manager.js';
 const statusCommand = new Command('status')
     .description('Check if dev server is running in background')

package/dist/commands/dev/stop.js

@@ -1,7 +1,7 @@
-import { Command } from 'commander';
 import chalk from 'chalk';
-import Spinner from '../../utils/spinner.js';
+import { Command } from 'commander';
 import { DevProcessManager } from '../../services/dev/process-manager.js';
+import Spinner from '../../utils/spinner.js';
 const stopCommand = new Command('stop')
     .description('Stop the background dev server')
     .action(async () => {

package/dist/commands/dev.js

@@ -1,16 +1,10 @@
 import { Command } from 'commander';
-import * as fs from 'fs';
-import { spawn } from 'child_process';
-import chalk from 'chalk';
-import ConfigManager from '../services/config/manager.js';
-import ApiClient from '../services/api/client.js';
-import Spinner from '../utils/spinner.js';
-import { withRetry, CommandError } from '../utils/errors.js';
-import { DevProcessManager } from '../services/dev/process-manager.js';
 import { DevServer } from '../services/dev/server.js';
+import DevSessionService from '../services/dev/session.js';
+import logsCommand from './dev/logs.js';
 import statusCommand from './dev/status.js';
 import stopCommand from './dev/stop.js';
-import logsCommand from './dev/logs.js';
+import { createCommandContext, showNoConfigMessage } from './shared/runtime.js';
 const command = new Command('dev');
 command
     .description('Start local development server')
@@ -20,255 +14,13 @@ command
     .option('--ngrok-token <token>', 'ngrok authtoken (if not set in environment)')
     .option('-d, --detach', 'Run server in background (detached mode)')
     .action(async (options) => {
-    const spinner = new Spinner();
-    const configManager = new ConfigManager();
-    let tunnel;
-    if (options.detach) {
-        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;
-        }
-        const args = ['dist/index.js', '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;
-    }
-    try {
-        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;
-        }
-        spinner.succeed('Configuration loaded');
-        spinner.start('Creating tunnel...');
-        const port = parseInt(options.port || '3000');
-        const { default: ngrok } = await import('@ngrok/ngrok');
-        const tunnelUrl = await withRetry(async () => {
-            try {
-                const authtoken = options.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');
-                }
-                tunnel = await ngrok.forward({
-                    addr: port,
-                    authtoken: authtoken,
-                });
-                return tunnel.url();
-            }
-            catch (error) {
-                console.log(chalk.yellow('Debug: ngrok error details:'), error.message);
-                throw error;
-            }
-        }, {
-            maxRetries: 3,
-            delayMs: 2000,
-            retryCondition: (error) => {
-                return (error.message.includes('connection') ||
-                    error.message.includes('timeout') ||
-                    error.message.includes('tunnel') ||
-                    error.message.includes('ngrok') ||
-                    error.message.includes('authtoken'));
-            },
-        });
-        spinner.succeed('Tunnel created');
-        const devServer = new DevServer(port, config);
-        await devServer.start();
-        if (config.registeredWebhooks && config.registeredWebhooks.length > 0) {
-            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 configManager.save(config);
-            if (cleanedCount > 0) {
-                spinner.succeed(`Cleaned up ${cleanedCount} stale webhook(s)`);
-            }
-            else {
-                spinner.succeed('No stale webhooks to clean up');
-            }
-        }
-        let webhookId;
-        const shouldRegister = !options.noRegister && config.dev.autoRegisterWebhook !== false;
-        if (shouldRegister) {
-            spinner.start('Registering webhook...');
-            const events = (options.events || 'payment.paid,payment.failed').split(',');
-            const projectSlug = config.projectName.toLowerCase().replace(/[^a-z0-9]/g, '-');
-            const webhookUrl = `${tunnelUrl}/webhook/${projectSlug}`;
-            try {
-                const webhook = await new ApiClient({ config }).createWebhook(webhookUrl, events);
-                webhookId = webhook.id;
-                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 configManager.save(config);
-                if (webhook.attributes?.secret) {
-                    spinner.succeed(`Webhook registered: ${webhookId} (with signature verification)`);
-                }
-                else {
-                    spinner.succeed(`Webhook registered: ${webhookId}`);
-                }
-            }
-            catch (error) {
-                const err = error;
-                spinner.warn('Webhook registration failed - server will start without webhook');
-                console.log(chalk.yellow('⚠️'), 'Webhook registration failed:', err.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 (err.message.includes('API key') || err.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'));
-                }
-            }
-        }
-        const projectSlug = config.projectName.toLowerCase().replace(/[^a-z0-9]/g, '-');
-        const localWebhookUrl = `http://localhost:${port}/webhook/${projectSlug}`;
-        const externalWebhookUrl = `${tunnelUrl}/webhook/${projectSlug}`;
-        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:'), (options.events || 'payment.paid,payment.failed').split(',').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'));
-        await DevProcessManager.saveState({
-            pid: process.pid,
-            port,
-            tunnelUrl: tunnelUrl ?? '',
-            webhookId,
-            webhookUrl: externalWebhookUrl,
-            localUrl: localWebhookUrl,
-            events: (options.events || 'payment.paid,payment.failed').split(','),
-            startedAt: Date.now(),
-            projectName: config.projectName,
-        });
-        const cleanup = async () => {
-            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) {
-                    spinner.start('Cleaning up webhook...');
-                    await new ApiClient({ config }).disableWebhook(webhookId);
-                    if (config.registeredWebhooks) {
-                        config.registeredWebhooks = config.registeredWebhooks.filter((w) => w.id !== webhookId);
-                        delete config.webhookSecrets[webhookId];
-                        await configManager.save(config);
-                    }
-                    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);
-        };
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
-        await new Promise(() => { });
-    }
-    catch (error) {
-        spinner.stop();
-        const err = error;
-        if (err.message.includes('ngrok') || err.message.includes('tunnel')) {
-            console.error(chalk.red('❌ Failed to create tunnel:'), err.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'));
-        }
-        await DevProcessManager.clearState();
-        try {
-            if (tunnel) {
-                await tunnel.close();
-            }
-        }
-        catch {
-        }
-        throw new CommandError();
-    }
+    const { spinner, configManager } = createCommandContext();
+    const session = new DevSessionService({
+        spinner,
+        configManager,
+        onMissingConfig: showNoConfigMessage,
+    });
+    await session.run(options);
 });
 command.addCommand(statusCommand);
 command.addCommand(stopCommand);

package/dist/commands/doctor.js

@@ -1,9 +1,8 @@
-import { Command } from 'commander';
 import chalk from 'chalk';
-import ConfigManager from '../services/config/manager.js';
-import ApiClient from '../services/api/client.js';
+import { Command } from 'commander';
+import { ApiKeyError, CommandError, NetworkError, PayMongoError } from '../utils/errors.js';
 import { validateApiKey, validateWebhookUrl } from '../utils/validator.js';
-import { ApiKeyError, NetworkError, PayMongoError, CommandError } from '../utils/errors.js';
+import { createApiClient, createCommandContext } from './shared/runtime.js';
 function statusIcon(status) {
     switch (status) {
         case 'pass':
@@ -25,7 +24,7 @@ function hasNgrokToken() {
     return typeof token === 'string' && token.trim().length > 0;
 }
 async function runDoctor(options) {
-    const configManager = new ConfigManager();
+    const { configManager } = createCommandContext();
     const checks = [];
     const config = await configManager.load();
     if (!config) {
@@ -33,7 +32,7 @@ async function runDoctor(options) {
             name: 'Configuration',
             status: 'fail',
             message: 'No .paymongo configuration found.',
-            fix: "Run `paymongo init` to create project configuration.",
+            fix: 'Run `paymongo init` to create project configuration.',
         });
         return checks;
     }
@@ -159,7 +158,7 @@ async function runDoctor(options) {
             : 'No project-managed webhooks are currently tracked.',
     });
     if (options.network !== false && envKeys?.secret && validateApiKey(envKeys.secret, 'secret')) {
-        const apiClient = new ApiClient({ config });
+        const apiClient = createApiClient(config);
         try {
             await apiClient.validateApiKey();
             checks.push({