paymongo-cli 1.4.11 → 1.4.13

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;

package/dist/services/team/service.js

@@ -1,5 +1,5 @@
+import crypto from 'node:crypto';
 import { PayMongoError } from '../../utils/errors.js';
-import crypto from 'crypto';
 export class TeamService {
     config;
     constructor(options) {

package/dist/utils/bulk.js

@@ -1,5 +1,5 @@
-import { promises as fs } from 'fs';
-import path from 'path';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
 import { PayMongoError } from './errors.js';
 export class BulkOperations {
     static EXPORT_VERSION = '1.0';
@@ -8,7 +8,7 @@ export class BulkOperations {
             metadata: {
                 exported_at: new Date().toISOString(),
                 exported_by: 'paymongo-cli',
-                version: this.EXPORT_VERSION,
+                version: BulkOperations.EXPORT_VERSION,
                 environment,
             },
             data: webhooks,
@@ -22,7 +22,7 @@ export class BulkOperations {
             metadata: {
                 exported_at: new Date().toISOString(),
                 exported_by: 'paymongo-cli',
-                version: this.EXPORT_VERSION,
+                version: BulkOperations.EXPORT_VERSION,
                 environment,
             },
             data: payments,
@@ -50,7 +50,7 @@ export class BulkOperations {
         catch {
             throw new PayMongoError(`Invalid JSON in ${filename}`, 'INVALID_JSON', 400);
         }
-        this.validateImportData(data, 'webhooks');
+        BulkOperations.validateImportData(data, 'webhooks');
         return {
             webhooks: data.data,
             metadata: data.metadata,
@@ -75,7 +75,7 @@ export class BulkOperations {
         catch {
             throw new PayMongoError(`Invalid JSON in ${filename}`, 'INVALID_JSON', 400);
         }
-        this.validateImportData(data, 'payments');
+        BulkOperations.validateImportData(data, 'payments');
         return {
             payments: data.data,
             metadata: data.metadata,
@@ -93,17 +93,17 @@ export class BulkOperations {
         if (typeof metadata.version !== 'string') {
             throw new PayMongoError('Invalid metadata - version must be a string', 'INVALID_FILE_FORMAT', 400);
         }
-        if (metadata.version !== this.EXPORT_VERSION) {
-            throw new PayMongoError(`Unsupported export version: ${metadata.version}. Current version: ${this.EXPORT_VERSION}`, 'UNSUPPORTED_VERSION', 400);
+        if (metadata.version !== BulkOperations.EXPORT_VERSION) {
+            throw new PayMongoError(`Unsupported export version: ${metadata.version}. Current version: ${BulkOperations.EXPORT_VERSION}`, 'UNSUPPORTED_VERSION', 400);
         }
         if (obj.data.length === 0) {
             throw new PayMongoError('No data found in export file', 'EMPTY_FILE', 400);
         }
         if (type === 'webhooks') {
-            this.validateWebhookData(obj.data);
+            BulkOperations.validateWebhookData(obj.data);
         }
         else if (type === 'payments') {
-            this.validatePaymentData(obj.data);
+            BulkOperations.validatePaymentData(obj.data);
         }
     }
     static validateWebhookData(webhooks) {
@@ -150,6 +150,6 @@ export class BulkOperations {
         if (path.extname(filename).toLowerCase() === '.json') {
             return filename;
         }
-        return filename + '.json';
+        return `${filename}.json`;
     }
 }

package/dist/utils/cache.js

@@ -1,7 +1,7 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as crypto from 'crypto';
-import { homedir } from 'os';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import { homedir } from 'node:os';
+import * as path from 'node:path';
 export class Cache {
     cacheDir;
     options;
@@ -26,7 +26,7 @@ export class Cache {
         return crypto.createHash('md5').update(key).digest('hex');
     }
     getCachePath(key) {
-        return path.join(this.cacheDir, this.getCacheKey(key) + '.json');
+        return path.join(this.cacheDir, `${this.getCacheKey(key)}.json`);
     }
     async isExpired(filePath) {
         try {

package/dist/utils/constants.js

@@ -12,7 +12,7 @@ export const ENVIRONMENTS = ['test', 'live'];
 export const CONFIG_FILE_NAME = '.paymongo';
 export const ENV_FILE_NAME = '.env';
 export const CLI_NAME = 'paymongo';
-import { createRequire } from 'module';
+import { createRequire } from 'node:module';
 const _require = createRequire(import.meta.url);
 const _pkg = _require('../../package.json');
 export const CLI_VERSION = _pkg.version;

package/dist/utils/webhook-store.js

@@ -1,6 +1,6 @@
-import fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
+import fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
 class WebhookEventStore {
     storePath;
     storeDir;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paymongo-cli",
-  "version": "1.4.11",
+  "version": "1.4.13",
   "description": "Developer-first CLI tool for PayMongo integration development with local webhook forwarding, payment testing, and team collaboration features. See USER_GUIDE.md for comprehensive documentation.",
   "type": "module",
   "main": "dist/index.js",
@@ -12,23 +12,17 @@
     "build:incremental": "tsc --incremental",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
-    "test": "cross-env NODE_NO_WARNINGS=1 node --experimental-vm-modules node_modules/jest/bin/jest.js",
-    "test:watch": "cross-env NODE_NO_WARNINGS=1 node --experimental-vm-modules node_modules/jest/bin/jest.js --watch",
-    "lint": "cross-env NODE_OPTIONS='--max-old-space-size=4096' eslint src/**/*.ts tests/**/*.ts",
-    "lint:fix": "eslint src/**/*.ts --fix",
-    "lint:src": "cross-env NODE_OPTIONS='--max-old-space-size=4096' eslint src/**/*.ts",
-    "lint:tests": "cross-env NODE_OPTIONS='--max-old-space-size=4096' eslint tests/**/*.ts",
-    "format": "prettier --write src/**/*.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "lint:src": "biome check src",
+    "lint:tests": "biome check tests",
+    "format": "biome format --write .",
     "benchmark": "npx tsx scripts/benchmark.ts",
     "prepare": "npm run build"
   },
-  "keywords": [
-    "paymongo",
-    "cli",
-    "payments",
-    "webhooks",
-    "development"
-  ],
+  "keywords": ["paymongo", "cli", "payments", "webhooks", "development"],
   "author": "Leodyver Semilla",
   "license": "MIT",
   "repository": {
@@ -54,20 +48,12 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@eslint/js": "^9.0.0",
-    "@types/jest": "^30.0.0",
+    "@biomejs/biome": "2.4.10",
     "@types/node": "^25.0.10",
-    "cross-env": "^10.1.0",
-    "eslint": "^9.0.0",
-    "globals": "^17.1.0",
-    "jest": "^30.2.0",
-    "jiti": "^2.6.1",
-    "prettier": "^3.1.1",
-    "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "tsx": "^4.7.0",
     "typescript": "^5.3.3",
-    "typescript-eslint": "^8.0.0"
+    "vitest": "^4.1.2"
   },
   "publishConfig": {
     "access": "public"

package/vitest.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: true,
+    include: ['tests/**/*.test.ts'],
+    setupFiles: ['tests/setup-vitest.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'lcov', 'html'],
+      reportsDirectory: 'coverage',
+      include: ['src/**/*.ts'],
+      exclude: ['src/**/*.d.ts'],
+    },
+    silent: true,
+  },
+});

package/eslint.config.ts

@@ -1,70 +0,0 @@
-import eslint from '@eslint/js';
-import tseslint from 'typescript-eslint';
-import globals from 'globals';
-
-export default tseslint.config(
-  eslint.configs.recommended,
-  ...tseslint.configs.recommended,
-  {
-    files: ['src/**/*.ts'],
-    languageOptions: {
-      ecmaVersion: 2022,
-      sourceType: 'module',
-      globals: {
-        ...globals.node,
-        ...globals.es2022,
-      },
-      parserOptions: {
-        project: './tsconfig.json',
-      },
-    },
-    rules: {
-      'no-unused-vars': 'off',
-      '@typescript-eslint/no-unused-vars': ['warn', { 
-        argsIgnorePattern: '^_',
-        varsIgnorePattern: '^_',
-        caughtErrorsIgnorePattern: '^_'
-      }],
-      'no-console': 'off',
-      'no-redeclare': 'off',
-      '@typescript-eslint/no-redeclare': 'error',
-      'no-shadow': 'off',
-      '@typescript-eslint/no-shadow': 'error',
-      'no-undef': 'off',
-      'no-empty': 'error',
-      '@typescript-eslint/explicit-function-return-type': 'off',
-      '@typescript-eslint/no-explicit-any': 'warn',
-      '@typescript-eslint/no-non-null-assertion': 'warn',
-      eqeqeq: ['error', 'always'],
-      curly: ['error', 'all'],
-      'no-var': 'error',
-      'prefer-const': 'error',
-    },
-  },
-  {
-    files: ['tests/**/*.ts'],
-    languageOptions: {
-      ecmaVersion: 2022,
-      sourceType: 'module',
-      globals: {
-        ...globals.node,
-        ...globals.es2022,
-        ...globals.jest,
-      },
-    },
-    rules: {
-      'no-unused-vars': 'off',
-      '@typescript-eslint/no-unused-vars': ['warn', { 
-        argsIgnorePattern: '^_',
-        varsIgnorePattern: '^_',
-        caughtErrorsIgnorePattern: '^_'
-      }],
-      '@typescript-eslint/no-explicit-any': 'off', // Allow any in tests for mocking
-      'no-console': 'off',
-      'no-undef': 'off',
-    },
-  },
-  {
-    ignores: ['dist/', 'node_modules/', '*.js', '*.cjs', 'coverage/'],
-  }
-);