neex 0.6.47 → 0.6.51

package/dist/src/commands/start-commands.js

@@ -6,55 +6,239 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addStartCommands = void 0;
 const start_manager_js_1 = require("../start-manager.js");
 const logger_manager_js_1 = require("../logger-manager.js");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 function addStartCommands(program) {
-    let manager = null;
-    const startCommand = program
-        .command('start [entry]')
-        .description('Start a production-ready application')
-        .option('-n, --name <name>', 'Application name')
-        .option('-w, --watch', 'Watch for file changes and restart the application', false)
-        .option('--quiet', 'Suppress all output', false)
-        .option('--color', 'Force color output', true)
-        .option('--verbose', 'Enable verbose logging', false)
-        .option('--node-args <args>', 'Arguments to pass to the node process', (value) => value.split(' '), [])
-        .action(async (entry, options) => {
-        let entryPoint = entry;
-        if (!entryPoint) {
-            const defaultPath = path_1.default.join(process.cwd(), 'dist', 'index.js');
-            if (fs_1.default.existsSync(defaultPath)) {
-                entryPoint = defaultPath;
+    let startManager = null;
+    // Start command for production execution
+    program
+        .command('start [file]')
+        .description('Start production application (default: dist/index.js)')
+        .option('-d, --dir <directory>', 'Working directory', process.cwd())
+        .option('-e, --env <file>', 'Environment file to load', '.env')
+        .option('-p, --port <port>', 'Port number (if applicable)', parseInt)
+        .option('-w, --workers <count>', 'Number of worker processes', parseInt, 1)
+        .option('-c, --cluster', 'Enable cluster mode')
+        .option('-m, --memory <limit>', 'Memory limit (e.g., 512M, 1G)')
+        .option('-l, --log-level <level>', 'Log level (error, warn, info, debug)', 'info')
+        .option('-f, --log-file <file>', 'Log file path')
+        .option('--no-color', 'Disable colored output')
+        .option('-q, --quiet', 'Quiet mode')
+        .option('-v, --verbose', 'Verbose output')
+        .option('--watch', 'Watch for changes and restart')
+        .option('--max-memory <limit>', 'Maximum memory before restart (e.g., 1G)')
+        .option('--max-crashes <count>', 'Maximum crashes before giving up', parseInt, 5)
+        .option('--restart-delay <ms>', 'Delay between restarts (ms)', parseInt, 1000)
+        .option('--health-check', 'Enable health check monitoring')
+        .option('--health-port <port>', 'Health check port', parseInt, 3001)
+        .option('--graceful-timeout <ms>', 'Graceful shutdown timeout (ms)', parseInt, 30000)
+        .option('--inspect', 'Enable Node.js inspector')
+        .option('--inspect-brk', 'Enable Node.js inspector with break')
+        .option('--node-args <args>', 'Additional Node.js arguments')
+        .action(async (file, options) => {
+        try {
+            const targetFile = file || 'dist/index.js';
+            const resolvedFile = path_1.default.resolve(options.dir, targetFile);
+            // Check if file exists
+            if (!fs_1.default.existsSync(resolvedFile)) {
+                // Try to find main file from package.json
+                const packageJsonPath = path_1.default.join(options.dir, 'package.json');
+                if (fs_1.default.existsSync(packageJsonPath)) {
+                    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+                    const mainFile = packageJson.main || 'index.js';
+                    const alternativeFile = path_1.default.resolve(options.dir, mainFile);
+                    if (fs_1.default.existsSync(alternativeFile)) {
+                        if (options.verbose) {
+                            logger_manager_js_1.loggerManager.printLine(`Using main file from package.json: ${mainFile}`, 'info');
+                        }
+                    }
+                    else {
+                        throw new Error(`Neither ${targetFile} nor ${mainFile} found. Please build your project first.`);
+                    }
+                }
+                else {
+                    throw new Error(`File not found: ${resolvedFile}. Please build your project first.`);
+                }
+            }
+            if (!options.quiet) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting production server: ${chalk_1.default.cyan(targetFile)}`, 'info');
+            }
+            startManager = new start_manager_js_1.StartManager({
+                file: resolvedFile,
+                workingDir: options.dir,
+                envFile: options.env,
+                port: options.port,
+                workers: options.workers,
+                cluster: options.cluster,
+                memoryLimit: options.memory,
+                logLevel: options.logLevel,
+                logFile: options.logFile,
+                color: options.color,
+                quiet: options.quiet,
+                verbose: options.verbose,
+                watch: options.watch,
+                maxMemory: options.maxMemory,
+                maxCrashes: options.maxCrashes,
+                restartDelay: options.restartDelay,
+                healthCheck: options.healthCheck,
+                healthPort: options.healthPort,
+                gracefulTimeout: options.gracefulTimeout,
+                inspect: options.inspect,
+                inspectBrk: options.inspectBrk,
+                nodeArgs: options.nodeArgs
+            });
+            await startManager.start();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Start failed: ${error.message}`, 'error');
             }
             else {
-                logger_manager_js_1.loggerManager.printLine('Entry file not found. Please specify an entry file or build the project first.', 'error');
-                process.exit(1);
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown start error occurred`, 'error');
             }
+            process.exit(1);
         }
-        const startOptions = {
-            entry: entryPoint,
-            name: options.name,
-            watch: options.watch,
-            quiet: options.quiet,
-            color: options.color,
-            verbose: options.verbose,
-            nodeArgs: options.nodeArgs,
-        };
-        manager = new start_manager_js_1.StartManager(startOptions);
+    });
+    // Quick start command
+    program
+        .command('run [file]')
+        .description('Quick start without options (alias for start)')
+        .action(async (file) => {
         try {
-            await manager.start();
+            const targetFile = file || 'dist/index.js';
+            if (!fs_1.default.existsSync(targetFile)) {
+                throw new Error(`File not found: ${targetFile}. Please build your project first.`);
+            }
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Running: ${chalk_1.default.cyan(targetFile)}`, 'info');
+            startManager = new start_manager_js_1.StartManager({
+                file: path_1.default.resolve(targetFile),
+                workingDir: process.cwd(),
+                envFile: '.env',
+                port: undefined,
+                workers: 1,
+                cluster: false,
+                memoryLimit: undefined,
+                logLevel: 'info',
+                logFile: undefined,
+                color: true,
+                quiet: false,
+                verbose: false,
+                watch: false,
+                maxMemory: undefined,
+                maxCrashes: 5,
+                restartDelay: 1000,
+                healthCheck: false,
+                healthPort: 3001,
+                gracefulTimeout: 30000,
+                inspect: false,
+                inspectBrk: false,
+                nodeArgs: undefined
+            });
+            await startManager.start();
         }
         catch (error) {
-            logger_manager_js_1.loggerManager.printLine(error.message, 'error');
+            if (error instanceof Error) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Run failed: ${error.message}`, 'error');
+            }
+            else {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown run error occurred`, 'error');
+            }
             process.exit(1);
         }
     });
-    return {
-        cleanupStart: async () => {
-            if (manager) {
-                await manager.stop();
+    // Production command with clustering
+    program
+        .command('prod [file]')
+        .description('Start in production mode with clustering')
+        .option('-w, --workers <count>', 'Number of workers (default: CPU cores)', parseInt)
+        .option('-p, --port <port>', 'Port number', parseInt)
+        .option('-e, --env <file>', 'Environment file', '.env.production')
+        .option('-l, --log-file <file>', 'Log file path')
+        .option('-q, --quiet', 'Quiet mode')
+        .action(async (file, options) => {
+        try {
+            const targetFile = file || 'dist/index.js';
+            const resolvedFile = path_1.default.resolve(targetFile);
+            if (!fs_1.default.existsSync(resolvedFile)) {
+                throw new Error(`File not found: ${resolvedFile}. Please build your project first.`);
+            }
+            const workers = options.workers || require('os').cpus().length;
+            if (!options.quiet) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting production server with ${workers} workers`, 'info');
             }
-        },
+            startManager = new start_manager_js_1.StartManager({
+                file: resolvedFile,
+                workingDir: process.cwd(),
+                envFile: options.env,
+                port: options.port,
+                workers,
+                cluster: true,
+                memoryLimit: undefined,
+                logLevel: 'info',
+                logFile: options.logFile,
+                color: false,
+                quiet: options.quiet,
+                verbose: false,
+                watch: false,
+                maxMemory: '1G',
+                maxCrashes: 3,
+                restartDelay: 2000,
+                healthCheck: true,
+                healthPort: 3001,
+                gracefulTimeout: 30000,
+                inspect: false,
+                inspectBrk: false,
+                nodeArgs: undefined
+            });
+            await startManager.start();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Production start failed: ${error.message}`, 'error');
+            }
+            else {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown production start error occurred`, 'error');
+            }
+            process.exit(1);
+        }
+    });
+    // Cleanup function
+    const cleanupStart = async () => {
+        if (startManager) {
+            try {
+                await startManager.stop();
+                startManager = null;
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+        }
     };
+    // Handle process termination
+    const handleExit = (signal) => {
+        if (startManager) {
+            logger_manager_js_1.loggerManager.printLine(`\n${chalk_1.default.yellow(figures_1.default.warning)} Received ${signal}, stopping server...`, 'info');
+            cleanupStart().then(() => {
+                process.exit(0);
+            }).catch(() => {
+                process.exit(1);
+            });
+        }
+        else {
+            process.exit(0);
+        }
+    };
+    // Register signal handlers
+    process.on('SIGINT', () => handleExit('SIGINT'));
+    process.on('SIGTERM', () => handleExit('SIGTERM'));
+    process.on('SIGUSR2', () => handleExit('SIGUSR2')); // PM2 restart
+    process.on('exit', () => {
+        if (startManager) {
+            cleanupStart();
+        }
+    });
+    return { cleanupStart };
 }
 exports.addStartCommands = addStartCommands;

package/dist/src/dev-manager.js

@@ -46,97 +46,20 @@ class DevManager {
             }
         }
     }
-    detectRuntime() {
-        // Check if we're running in Bun
-        if (typeof globalThis.Bun !== 'undefined' || process.versions.bun) {
-            return 'bun';
-        }
-        // Check if we're running in Deno
-        if (typeof globalThis.Deno !== 'undefined') {
-            return 'deno';
-        }
-        return 'node';
-    }
     getExecuteCommand() {
         if (this.options.execCommand) {
             const parts = this.options.execCommand.split(' ');
             return { command: parts[0], args: [...parts.slice(1), this.options.file] };
         }
-        const runtime = this.detectRuntime();
-        const isTypeScript = this.options.file.endsWith('.ts') || this.options.useTypeScript;
-        let command;
-        let args = [];
-        switch (runtime) {
-            case 'bun':
-                command = 'bun';
-                args = ['run', this.options.file];
-                break;
-            case 'deno':
-                command = 'deno';
-                args = ['run', '--allow-all', this.options.file];
-                break;
-            case 'node':
-            default:
-                command = 'node';
-                if (isTypeScript) {
-                    // Try different TypeScript execution methods
-                    if (this.commandExists('tsx')) {
-                        command = 'tsx';
-                        args = [this.options.file];
-                    }
-                    else if (this.commandExists('ts-node')) {
-                        command = 'ts-node';
-                        args = [this.options.file];
-                    }
-                    else {
-                        // Fallback: try to use node with --loader
-                        const tsNodePath = this.findTsNodePath();
-                        if (tsNodePath) {
-                            args = ['--loader', tsNodePath, this.options.file];
-                        }
-                        else {
-                            throw new Error('TypeScript execution not available. Please install tsx or ts-node');
-                        }
-                    }
-                }
-                else {
-                    // Regular JavaScript file
-                    args = [this.options.file];
-                }
-                break;
-        }
-        // Add inspect flags for Node.js
-        if (runtime === 'node' && command === 'node') {
-            if (this.options.inspect) {
-                args.unshift('--inspect');
-            }
-            if (this.options.inspectBrk) {
-                args.unshift('--inspect-brk');
-            }
-        }
-        return { command, args };
-    }
-    commandExists(command) {
-        try {
-            const { execSync } = require('child_process');
-            execSync(`which ${command}`, { stdio: 'ignore' });
-            return true;
-        }
-        catch (_a) {
-            return false;
+        // Default to tsx for TypeScript files
+        const args = [this.options.file];
+        if (this.options.inspect) {
+            args.unshift('--inspect');
         }
-    }
-    findTsNodePath() {
-        const paths = [
-            path_1.default.join(process.cwd(), 'node_modules', 'ts-node', 'esm.mjs'),
-            path_1.default.join(process.cwd(), 'node_modules', 'ts-node', 'register.js'),
-        ];
-        for (const tsPath of paths) {
-            if (fs_1.default.existsSync(tsPath)) {
-                return tsPath;
-            }
+        if (this.options.inspectBrk) {
+            args.unshift('--inspect-brk');
         }
-        return null;
+        return { command: 'tsx', args };
     }
     clearConsole() {
         if (this.options.clearConsole && process.stdout.isTTY) {
@@ -149,66 +72,50 @@ class DevManager {
             return;
         }
         this.loadEnvFile();
-        try {
-            const { command, args } = this.getExecuteCommand();
-            if (this.options.verbose) {
-                logger_manager_js_1.loggerManager.printLine(`Executing: ${command} ${args.join(' ')}`, 'info');
+        const { command, args } = this.getExecuteCommand();
+        if (this.options.verbose) {
+            logger_manager_js_1.loggerManager.printLine(`Executing: ${command} ${args.join(' ')}`, 'info');
+        }
+        this.process = (0, child_process_1.spawn)(command, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: false,
+            env: {
+                ...process.env,
+                NODE_ENV: process.env.NODE_ENV || 'development',
+                FORCE_COLOR: this.options.color ? '1' : '0'
+            },
+            detached: true
+        });
+        this.startTime = new Date();
+        this.restartCount++;
+        if (!this.options.quiet) {
+            const timestamp = new Date().toLocaleTimeString();
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.play)} Started ${chalk_1.default.cyan(this.options.file)} ${chalk_1.default.dim(`(${timestamp})`)}`, 'info');
+        }
+        (_a = this.process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+            if (!this.options.quiet) {
+                process.stdout.write(data);
             }
-            this.process = (0, child_process_1.spawn)(command, args, {
-                stdio: ['ignore', 'pipe', 'pipe'],
-                shell: false,
-                env: {
-                    ...process.env,
-                    NODE_ENV: process.env.NODE_ENV || 'development',
-                    FORCE_COLOR: this.options.color ? '1' : '0',
-                    // Add common TypeScript environment variables
-                    TS_NODE_COMPILER_OPTIONS: '{"module":"commonjs","target":"es2020"}',
-                    TS_NODE_TRANSPILE_ONLY: 'true'
-                },
-                detached: true
-            });
-            this.startTime = new Date();
-            this.restartCount++;
+        });
+        (_b = this.process.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
             if (!this.options.quiet) {
-                const timestamp = new Date().toLocaleTimeString();
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.play)} Started ${chalk_1.default.cyan(this.options.file)} ${chalk_1.default.dim(`(${timestamp})`)}`, 'info');
+                process.stderr.write(data);
             }
-            (_a = this.process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-                if (!this.options.quiet) {
-                    process.stdout.write(data);
-                }
-            });
-            (_b = this.process.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
-                if (!this.options.quiet) {
-                    process.stderr.write(data);
-                }
-            });
-            this.process.on('error', (error) => {
-                logger_manager_js_1.loggerManager.printLine(`Process error: ${error.message}`, 'error');
-                // Provide helpful error messages
-                if (error.message.includes('ENOENT')) {
-                    logger_manager_js_1.loggerManager.printLine(`Command not found. Make sure the required runtime is installed.`, 'error');
-                }
-                else if (error.message.includes('EACCES')) {
-                    logger_manager_js_1.loggerManager.printLine(`Permission denied. The command might not be executable.`, 'error');
-                }
-            });
-            this.process.on('exit', (code, signal) => {
-                if (this.process) {
-                    this.process = null;
-                    if (!this.isRestarting) {
-                        if (code !== 0) {
-                            const duration = this.startTime ? Date.now() - this.startTime.getTime() : 0;
-                            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Process exited with code ${code} after ${duration}ms`, 'error');
-                        }
+        });
+        this.process.on('error', (error) => {
+            logger_manager_js_1.loggerManager.printLine(`Process error: ${error.message}`, 'error');
+        });
+        this.process.on('exit', (code, signal) => {
+            if (this.process) {
+                this.process = null;
+                if (!this.isRestarting) {
+                    if (code !== 0) {
+                        const duration = this.startTime ? Date.now() - this.startTime.getTime() : 0;
+                        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Process exited with code ${code} after ${duration}ms`, 'error');
                     }
                 }
-            });
-        }
-        catch (error) {
-            logger_manager_js_1.loggerManager.printLine(`Failed to start process: ${error.message}`, 'error');
-            throw error;
-        }
+            }
+        });
     }
     async stopProcess() {
         if (!this.process) {
@@ -275,12 +182,6 @@ class DevManager {
             '**/dist/**',
             '**/build/**',
             '**/*.log',
-            '**/.next/**',
-            '**/.nuxt/**',
-            '**/.vscode/**',
-            '**/.idea/**',
-            '**/coverage/**',
-            '**/*.map',
             ...this.options.ignore.map(pattern => `**/${pattern}/**`)
         ];
         this.watcher = (0, chokidar_1.watch)(watchPatterns, {
@@ -288,11 +189,7 @@ class DevManager {
             ignoreInitial: true,
             followSymlinks: false,
             usePolling: false,
-            atomic: 300,
-            awaitWriteFinish: {
-                stabilityThreshold: 100,
-                pollInterval: 50
-            }
+            atomic: 300
         });
         this.watcher.on('change', (filePath) => {
             if (this.options.verbose) {
@@ -331,7 +228,6 @@ class DevManager {
             logger_manager_js_1.loggerManager.printLine(`Target file: ${this.options.file}`, 'info');
             logger_manager_js_1.loggerManager.printLine(`Watch patterns: ${this.options.watch.join(', ')}`, 'info');
             logger_manager_js_1.loggerManager.printLine(`Restart delay: ${this.options.delay}ms`, 'info');
-            logger_manager_js_1.loggerManager.printLine(`Runtime: ${this.detectRuntime()}`, 'info');
         }
         this.setupWatcher();
         await this.startProcess();