paymongo-cli 1.0.0 → 1.2.0

package/dist/commands/dev.js

@@ -1,50 +1,18 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const http = __importStar(require("http"));
-const crypto = __importStar(require("crypto"));
-const chalk_1 = __importDefault(require("chalk"));
-const manager_1 = __importDefault(require("../services/config/manager"));
-const client_1 = __importDefault(require("../services/api/client"));
-const spinner_1 = __importDefault(require("../utils/spinner"));
-const errors_1 = require("../utils/errors");
+import { Command } from 'commander';
+import * as http from 'http';
+import * as crypto from 'crypto';
+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 } from '../utils/errors.js';
+import { DevProcessManager } from '../services/dev/process-manager.js';
 class DevServer {
+    server;
+    port;
+    config;
     constructor(port, config) {
         this.port = port;
         this.config = config;
@@ -56,7 +24,7 @@ class DevServer {
         // Start HTTP server
         return new Promise((resolve, reject) => {
             this.server.listen(this.port, () => {
-                console.log(chalk_1.default.green('✓'), `Webhook server listening on http://localhost:${this.port}`);
+                console.log(chalk.green('✓'), `Webhook server listening on http://localhost:${this.port}`);
                 resolve();
             });
             this.server.on('error', (error) => {
@@ -67,13 +35,15 @@ class DevServer {
     async stop() {
         return new Promise((resolve) => {
             this.server.close(() => {
-                console.log(chalk_1.default.yellow('✓'), 'Webhook server stopped');
+                console.log(chalk.yellow('✓'), 'Webhook server stopped');
                 resolve();
             });
         });
     }
     handleWebhookRequest(req, res) {
-        if (req.method !== 'POST' || req.url !== '/webhook') {
+        // Accept both /webhook and /webhook/{project-slug} paths
+        const isWebhookPath = req.url?.startsWith('/webhook');
+        if (req.method !== 'POST' || !isWebhookPath) {
             res.writeHead(404);
             res.end('Not Found');
             return;
@@ -88,7 +58,7 @@ class DevServer {
                 // Verify webhook signature if enabled
                 const signatureValid = this.verifyWebhookSignature(req, body);
                 if (!signatureValid) {
-                    console.log(chalk_1.default.red('⚠️'), 'Webhook signature verification failed');
+                    console.log(chalk.red('⚠️'), 'Webhook signature verification failed');
                     res.writeHead(401, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ error: 'Invalid signature' }));
                     return;
@@ -99,7 +69,7 @@ class DevServer {
                 res.end(JSON.stringify({ success: true }));
             }
             catch (error) {
-                console.error(chalk_1.default.red('✗'), 'Failed to process webhook:', error.message);
+                console.error(chalk.red('✗'), 'Failed to process webhook:', error.message);
                 res.writeHead(400, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ error: 'Invalid JSON' }));
             }
@@ -110,38 +80,39 @@ class DevServer {
         const eventType = event.data?.type || 'unknown';
         const eventId = event.data?.id || 'unknown';
         console.log('');
-        console.log(chalk_1.default.gray('────────────────────────────────────────────────────────────'));
-        console.log(chalk_1.default.blue(`[${timestamp}]`), chalk_1.default.bold(eventType.toUpperCase()));
+        console.log(chalk.gray('────────────────────────────────────────────────────────────'));
+        console.log(chalk.blue(`[${timestamp}]`), chalk.bold(eventType.toUpperCase()));
         if (eventType === 'payment') {
-            const amount = event.data.attributes.amount;
-            const status = event.data.attributes.status;
-            console.log(chalk_1.default.gray('└─'), `Amount: ₱${(amount / 100).toFixed(2)}`);
-            console.log(chalk_1.default.gray('└─'), `Status: ${status}`);
-            console.log(chalk_1.default.gray('└─'), `Payment ID: ${eventId}`);
+            const attributes = event.data.attributes;
+            const amount = attributes.amount ?? 0;
+            const status = attributes.status ?? 'unknown';
+            console.log(chalk.gray('└─'), `Amount: ₱${(amount / 100).toFixed(2)}`);
+            console.log(chalk.gray('└─'), `Status: ${status}`);
+            console.log(chalk.gray('└─'), `Payment ID: ${eventId}`);
         }
-        console.log(chalk_1.default.gray('└─'), `View: https://dashboard.paymongo.com/${eventType === 'payment' ? 'payments' : 'webhooks'}/${eventId}`);
+        console.log(chalk.gray('└─'), `View: https://dashboard.paymongo.com/${eventType === 'payment' ? 'payments' : 'webhooks'}/${eventId}`);
     }
     verifyWebhookSignature(req, body) {
         // Check if signature verification is enabled in config
         if (!this.config.dev.verifyWebhookSignatures) {
-            console.log(chalk_1.default.yellow('ℹ️'), 'Webhook signature verification disabled in config');
+            console.log(chalk.yellow('ℹ️'), 'Webhook signature verification disabled in config');
             return true; // Allow all requests when verification is disabled
         }
         const signatureHeader = req.headers['paymongo-signature'];
         if (!signatureHeader) {
-            console.log(chalk_1.default.red('⚠️'), 'Signature verification required but no signature header found');
+            console.log(chalk.red('⚠️'), 'Signature verification required but no signature header found');
             return false;
         }
         // Parse signature header: t=<timestamp>,te=<signature>,li=
         const signatureParts = signatureHeader.split(',');
         if (signatureParts.length < 2) {
-            console.log(chalk_1.default.red('⚠️'), 'Invalid signature format');
+            console.log(chalk.red('⚠️'), '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_1.default.red('⚠️'), 'Missing timestamp or signature in header');
+            console.log(chalk.red('⚠️'), 'Missing timestamp or signature in header');
             return false;
         }
         // For now, look for any webhook secret in config
@@ -149,7 +120,7 @@ class DevServer {
         const webhookSecrets = this.config.webhookSecrets || {};
         const secretKeys = Object.values(webhookSecrets);
         if (secretKeys.length === 0) {
-            console.log(chalk_1.default.yellow('⚠️'), 'Signature verification enabled but no webhook secrets configured');
+            console.log(chalk.yellow('⚠️'), 'Signature verification enabled but no webhook secrets configured');
             return true; // Allow requests when no secrets are configured yet
         }
         // Try to verify with each available secret
@@ -165,40 +136,89 @@ class DevServer {
                     break;
                 }
             }
-            catch (error) {
+            catch (_error) {
                 // Continue trying other secrets
                 continue;
             }
         }
         if (isValid) {
-            console.log(chalk_1.default.green('✓'), 'Signature verified successfully');
+            console.log(chalk.green('✓'), 'Signature verified successfully');
             return true;
         }
         else {
-            console.log(chalk_1.default.red('✗'), 'Signature verification failed');
+            console.log(chalk.red('✗'), 'Signature verification failed');
             return false;
         }
     }
 }
-const command = new commander_1.Command('dev');
+const command = new Command('dev');
 command
     .description('Start local development server')
     .option('-p, --port <port>', 'Port to run the webhook server on', '3000')
     .option('--no-register', 'Skip automatic webhook registration')
     .option('-e, --events <events>', 'Comma-separated events to listen for', 'payment.paid,payment.failed')
     .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_1.default();
-    const configManager = new manager_1.default();
+    const spinner = new Spinner();
+    const configManager = new ConfigManager();
     let tunnel;
+    // Check if detach mode is requested
+    if (options.detach) {
+        // Check if already running
+        const existingState = 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;
+        }
+        // Spawn detached process
+        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 = 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'));
+        // Give the server a moment to start, then exit
+        await new Promise(resolve => setTimeout(resolve, 500));
+        return;
+    }
     try {
         // Load configuration
         spinner.start('Loading configuration...');
         const config = await configManager.load();
         if (!config) {
             spinner.fail('No configuration found');
-            console.log(chalk_1.default.yellow('No PayMongo configuration found.'));
-            console.log(chalk_1.default.gray("Run 'paymongo init' to set up your project first."));
+            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');
@@ -206,8 +226,8 @@ command
         spinner.start('Creating tunnel...');
         const port = parseInt(options.port || '3000');
         // Lazy load ngrok to reduce startup time
-        const { default: ngrok } = await Promise.resolve().then(() => __importStar(require('@ngrok/ngrok')));
-        const tunnelUrl = await (0, errors_1.withRetry)(async () => {
+        const { default: ngrok } = await import('@ngrok/ngrok');
+        const tunnelUrl = await withRetry(async () => {
             try {
                 // Try to get authtoken from command line option or environment
                 const authtoken = options.ngrokToken || process.env.NGROK_AUTHTOKEN;
@@ -224,7 +244,7 @@ command
                 return tunnel.url();
             }
             catch (error) {
-                console.log(chalk_1.default.yellow('Debug: ngrok error details:'), error.message);
+                console.log(chalk.yellow('Debug: ngrok error details:'), error.message);
                 throw error;
             }
         }, {
@@ -243,20 +263,54 @@ command
         // Start webhook server
         const devServer = new DevServer(port, config);
         await devServer.start();
+        // Clean up any stale webhooks from previous sessions
+        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.deleteWebhook(webhook.id);
+                    cleanedCount++;
+                }
+                catch {
+                    // Webhook may already be deleted, ignore errors
+                }
+            }
+            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');
+            }
+        }
         // Register webhook (unless disabled)
         let webhookId;
         if (!options.noRegister) {
             spinner.start('Registering webhook...');
             const events = (options.events || 'payment.paid,payment.failed').split(',');
-            const webhookUrl = `${tunnelUrl}/webhook`;
+            // Use project-specific webhook path
+            const projectSlug = config.projectName.toLowerCase().replace(/[^a-z0-9]/g, '-');
+            const webhookUrl = `${tunnelUrl}/webhook/${projectSlug}`;
             try {
-                const webhook = await new client_1.default({ config }).createWebhook(webhookUrl, events);
+                const webhook = await new ApiClient({ config }).createWebhook(webhookUrl, events);
                 webhookId = webhook.id;
-                // Store webhook secret if available
+                // Store webhook secret and track registered webhook
                 if (webhook.attributes?.secret) {
                     config.webhookSecrets = config.webhookSecrets || {};
                     config.webhookSecrets[webhook.id] = webhook.attributes.secret;
-                    await configManager.save(config);
+                }
+                // Track this webhook for project-specific cleanup
+                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 {
@@ -266,54 +320,83 @@ command
             catch (error) {
                 const err = error;
                 spinner.warn('Webhook registration failed - server will start without webhook');
-                console.log(chalk_1.default.yellow('⚠️'), 'Webhook registration failed:', err.message);
+                console.log(chalk.yellow('⚠️'), 'Webhook registration failed:', err.message);
                 console.log('');
-                console.log(chalk_1.default.blue('ℹ️'), 'You can still test webhooks manually:');
-                console.log(chalk_1.default.gray(`   Webhook URL: ${webhookUrl}`));
-                console.log(chalk_1.default.gray('   Copy this URL to your PayMongo dashboard'));
+                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'));
                 console.log('');
                 if (err.message.includes('API key') || err.message.includes('unauthorized')) {
-                    console.log(chalk_1.default.yellow('💡 To fix webhook registration:'));
-                    console.log(chalk_1.default.gray('   1. Run "paymongo login" to update your API keys'));
-                    console.log(chalk_1.default.gray('   2. Restart the development server'));
+                    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'));
                 }
             }
         }
         // Display status
-        console.log('\n' + chalk_1.default.green('🚀 PayMongo 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_1.default.green('✓'), `Tunnel: ${tunnelUrl}`);
-        if (webhookId) {
-            console.log(chalk_1.default.green('✓'), `Webhook: ${webhookId}`);
-        }
-        console.log(chalk_1.default.green('✓'), `Server: http://localhost:${port}/webhook`);
+        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_1.default.bold('Forwarding:'), `${tunnelUrl} → http://localhost:${port}`);
+        console.log(chalk.bold('Forwarding:'));
+        console.log(chalk.gray('  '), `${chalk.yellow(tunnelUrl)} ${chalk.gray('→')} ${chalk.green(`http://localhost:${port}`)}`);
         console.log('');
-        console.log(chalk_1.default.bold('Events:'), (options.events || 'payment.paid,payment.failed').split(',').join(', '));
+        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_1.default.gray('Press Ctrl+C to stop'));
+        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'));
+        // Save state for background process management
+        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,
+        });
         // Handle cleanup on exit
         const cleanup = async () => {
-            console.log('\n' + chalk_1.default.yellow('Shutting down...'));
+            console.log('\n' + chalk.yellow('Shutting down...'));
+            // Clear saved state
+            DevProcessManager.clearState();
             try {
                 // Disconnect ngrok
                 if (tunnel) {
                     await tunnel.close();
-                    console.log(chalk_1.default.yellow('✓'), 'Tunnel closed');
+                    console.log(chalk.yellow('✓'), 'Tunnel closed');
                 }
                 // Stop server
                 await devServer.stop();
-                // Delete webhook
+                // Delete webhook and remove from tracked list
                 if (webhookId) {
                     spinner.start('Cleaning up webhook...');
-                    await new client_1.default({ config }).deleteWebhook(webhookId);
+                    await new ApiClient({ config }).deleteWebhook(webhookId);
+                    // Remove from tracked webhooks
+                    if (config.registeredWebhooks) {
+                        config.registeredWebhooks = config.registeredWebhooks.filter(w => w.id !== webhookId);
+                        delete config.webhookSecrets[webhookId];
+                        await configManager.save(config);
+                    }
                     spinner.succeed('Webhook deleted');
                 }
             }
             catch (error) {
-                console.error(chalk_1.default.red('Error during cleanup:'), error.message);
-                console.log(chalk_1.default.yellow('⚠️'), 'Some cleanup tasks may not have completed');
+                console.error(chalk.red('Error during cleanup:'), error.message);
+                console.log(chalk.yellow('⚠️'), 'Some cleanup tasks may not have completed');
             }
             process.exit(0);
         };
@@ -327,17 +410,18 @@ command
         const err = error;
         // Provide actionable error messages based on error type
         if (err.message.includes('ngrok') || err.message.includes('tunnel')) {
-            console.error(chalk_1.default.red('❌ Failed to create tunnel:'), err.message);
+            console.error(chalk.red('❌ Failed to create tunnel:'), err.message);
             console.log('');
-            console.log(chalk_1.default.yellow('💡 Troubleshooting suggestions:'));
-            console.log(chalk_1.default.gray('• Check your internet connection'));
-            console.log(chalk_1.default.gray('• Make sure ngrok is not blocked by firewall/antivirus'));
-            console.log(chalk_1.default.gray('• Set up ngrok authentication: export NGROK_AUTHTOKEN=your_token'));
-            console.log(chalk_1.default.gray('• Get your authtoken from: https://dashboard.ngrok.com/get-started/your-authtoken'));
-            console.log(chalk_1.default.gray('• Try a different port: paymongo dev --port 3001'));
-            console.log(chalk_1.default.gray('• Visit https://ngrok.com for status updates'));
+            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'));
         }
         // Cleanup on error
+        DevProcessManager.clearState();
         try {
             if (tunnel) {
                 await tunnel.close();
@@ -349,5 +433,130 @@ command
         process.exit(1);
     }
 });
-exports.default = command;
+// Subcommand: dev status
+command
+    .command('status')
+    .description('Check if dev server is running in background')
+    .action(async () => {
+    const state = DevProcessManager.loadState();
+    if (!state) {
+        console.log(chalk.yellow('No dev server is running in background.'));
+        console.log(chalk.gray('Start one with: paymongo dev --detach'));
+        return;
+    }
+    const isRunning = DevProcessManager.isProcessRunning(state.pid);
+    if (!isRunning) {
+        console.log(chalk.yellow('Dev server process is not running (stale state).'));
+        DevProcessManager.clearState();
+        console.log(chalk.gray('Start a new one with: paymongo dev --detach'));
+        return;
+    }
+    console.log(chalk.green('✓ Dev server is running'));
+    console.log('');
+    console.log(chalk.bold('Process:'));
+    console.log(chalk.gray('  PID:'), state.pid);
+    console.log(chalk.gray('  Uptime:'), DevProcessManager.formatUptime(state.startedAt));
+    console.log(chalk.gray('  Project:'), state.projectName);
+    console.log('');
+    console.log(chalk.bold('URLs:'));
+    console.log(chalk.gray('  External:'), chalk.yellow(state.webhookUrl));
+    console.log(chalk.gray('  Local:'), chalk.green(state.localUrl));
+    console.log('');
+    console.log(chalk.bold('Configuration:'));
+    console.log(chalk.gray('  Port:'), state.port);
+    console.log(chalk.gray('  Events:'), state.events.join(', '));
+    if (state.webhookId) {
+        console.log(chalk.gray('  Webhook ID:'), state.webhookId);
+    }
+    console.log('');
+    console.log(chalk.gray('Use "paymongo dev stop" to stop the server'));
+    console.log(chalk.gray('Use "paymongo dev logs" to view server logs'));
+});
+// Subcommand: dev stop
+command
+    .command('stop')
+    .description('Stop the background dev server')
+    .action(async () => {
+    const spinner = new Spinner();
+    const state = DevProcessManager.loadState();
+    if (!state) {
+        console.log(chalk.yellow('No dev server is running in background.'));
+        return;
+    }
+    const isRunning = DevProcessManager.isProcessRunning(state.pid);
+    if (!isRunning) {
+        console.log(chalk.yellow('Dev server process is not running (cleaning up stale state).'));
+        DevProcessManager.clearState();
+        return;
+    }
+    spinner.start('Stopping dev server...');
+    // Kill the process
+    const killed = DevProcessManager.killProcess(state.pid);
+    if (killed) {
+        // Wait a moment for cleanup
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        DevProcessManager.clearState();
+        spinner.succeed('Dev server stopped');
+        // Note: The webhook might still be registered if the process didn't clean up properly
+        // The next dev start will clean it up
+        console.log('');
+        console.log(chalk.gray('Note: If the webhook was not cleaned up, it will be removed on next "paymongo dev" start.'));
+    }
+    else {
+        spinner.fail('Failed to stop dev server');
+        console.log(chalk.yellow('Try manually killing the process:'));
+        console.log(chalk.gray(`  PID: ${state.pid}`));
+        if (process.platform === 'win32') {
+            console.log(chalk.gray(`  Run: taskkill /pid ${state.pid} /f`));
+        }
+        else {
+            console.log(chalk.gray(`  Run: kill -9 ${state.pid}`));
+        }
+    }
+});
+// Subcommand: dev logs
+command
+    .command('logs')
+    .description('View dev server logs')
+    .option('-n, --lines <number>', 'Number of lines to show', '50')
+    .option('-f, --follow', 'Follow log output (like tail -f)')
+    .option('--clear', 'Clear the log file')
+    .action(async (options) => {
+    if (options.clear) {
+        DevProcessManager.clearLogs();
+        console.log(chalk.green('✓ Logs cleared'));
+        return;
+    }
+    const logFile = DevProcessManager.getLogFile();
+    const lines = DevProcessManager.readLogs(parseInt(options.lines));
+    if (lines.length === 0) {
+        console.log(chalk.yellow('No logs available.'));
+        console.log(chalk.gray('Log file:'), logFile);
+        return;
+    }
+    console.log(chalk.bold('Dev Server 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));
+    if (options.follow) {
+        console.log('');
+        console.log(chalk.gray('Following logs... Press Ctrl+C to stop'));
+        let lastSize = fs.statSync(logFile).size;
+        fs.watchFile(logFile, { interval: 500 }, () => {
+            const newSize = fs.statSync(logFile).size;
+            if (newSize > lastSize) {
+                const fd = fs.openSync(logFile, 'r');
+                const buffer = Buffer.alloc(newSize - lastSize);
+                fs.readSync(fd, buffer, 0, buffer.length, lastSize);
+                fs.closeSync(fd);
+                process.stdout.write(buffer.toString());
+                lastSize = newSize;
+            }
+        });
+        // Keep process running
+        await new Promise(() => { });
+    }
+});
+export default command;
 //# sourceMappingURL=dev.js.map