neex 0.6.47 → 0.6.50

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

@@ -6,55 +6,250 @@ 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 path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const os_1 = __importDefault(require("os"));
 function addStartCommands(program) {
-    let manager = null;
-    const startCommand = program
+    let startManager = null;
+    // Main start command
+    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(' '), [])
+        .description('Start the production server (default: dist/index.js)')
+        .option('-p, --port <port>', 'Port to run the server on', '3000')
+        .option('-h, --host <host>', 'Host to bind the server to', '0.0.0.0')
+        .option('-e, --env <env>', 'Environment mode', 'production')
+        .option('-w, --watch', 'Watch for file changes and restart')
+        .option('-c, --cluster', 'Enable cluster mode')
+        .option('--workers <count>', 'Number of worker processes (default: CPU count)', os_1.default.cpus().length.toString())
+        .option('-m, --memory <mb>', 'Memory limit in MB', '512')
+        .option('-t, --timeout <ms>', 'Startup timeout in milliseconds', '30000')
+        .option('--graceful-timeout <ms>', 'Graceful shutdown timeout in milliseconds', '5000')
+        .option('-v, --verbose', 'Verbose output')
+        .option('-q, --quiet', 'Quiet output')
+        .option('--no-color', 'Disable colored output')
+        .option('--log-level <level>', 'Log level (error, warn, info, debug)', 'info')
+        .option('--node-args <args>', 'Additional Node.js arguments (comma-separated)')
+        .option('--inspect', 'Enable Node.js inspector')
+        .option('--inspect-port <port>', 'Inspector port', '9229')
+        .option('--pid <file>', 'Write process ID to file')
+        .option('--restart', 'Auto-restart on failure', true)
+        .option('--restart-delay <ms>', 'Delay between restarts in milliseconds', '1000')
+        .option('--max-restarts <count>', 'Maximum restart attempts', '10')
         .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;
+        try {
+            const entryFile = entry || 'dist/index.js';
+            if (!options.quiet) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting production server...`, 'info');
+            }
+            const nodeArgs = options.nodeArgs ?
+                options.nodeArgs.split(',').map((arg) => arg.trim()) : [];
+            startManager = new start_manager_js_1.StartManager({
+                entry: entryFile,
+                port: parseInt(options.port),
+                host: options.host,
+                env: options.env,
+                watch: options.watch,
+                cluster: options.cluster,
+                workers: parseInt(options.workers),
+                memory: parseInt(options.memory),
+                timeout: parseInt(options.timeout),
+                gracefulTimeout: parseInt(options.gracefulTimeout),
+                verbose: options.verbose,
+                quiet: options.quiet,
+                color: options.color,
+                logLevel: options.logLevel,
+                nodeArgs,
+                inspect: options.inspect,
+                inspectPort: parseInt(options.inspectPort),
+                pid: options.pid,
+                restart: options.restart,
+                restartDelay: parseInt(options.restartDelay),
+                maxRestarts: parseInt(options.maxRestarts)
+            });
+            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);
+        }
+    });
+    // Quick start command for development
+    program
+        .command('serve [entry]')
+        .description('Quick start with watch mode (development)')
+        .option('-p, --port <port>', 'Port to run the server on', '3000')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (entry, options) => {
+        try {
+            const entryFile = entry || 'dist/index.js';
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting development server...`, 'info');
+            startManager = new start_manager_js_1.StartManager({
+                entry: entryFile,
+                port: parseInt(options.port),
+                host: '127.0.0.1',
+                env: 'development',
+                watch: true,
+                cluster: false,
+                workers: 1,
+                memory: 256,
+                timeout: 15000,
+                gracefulTimeout: 3000,
+                verbose: options.verbose,
+                quiet: false,
+                color: true,
+                logLevel: 'info',
+                nodeArgs: [],
+                inspect: false,
+                inspectPort: 9229,
+                pid: '',
+                restart: true,
+                restartDelay: 500,
+                maxRestarts: 50
+            });
+            await startManager.start();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Serve failed: ${error.message}`, 'error');
             }
+            else {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown serve 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);
+    });
+    // Production deployment command
+    program
+        .command('deploy [entry]')
+        .description('Deploy to production with optimal settings')
+        .option('-p, --port <port>', 'Port to run the server on', process.env.PORT || '3000')
+        .option('-w, --workers <count>', 'Number of worker processes', os_1.default.cpus().length.toString())
+        .option('-m, --memory <mb>', 'Memory limit in MB', '1024')
+        .option('--pid <file>', 'Write process ID to file', 'server.pid')
+        .option('-v, --verbose', 'Verbose output')
+        .action(async (entry, options) => {
         try {
-            await manager.start();
+            const entryFile = entry || 'dist/index.js';
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Deploying to production...`, 'info');
+            startManager = new start_manager_js_1.StartManager({
+                entry: entryFile,
+                port: parseInt(options.port),
+                host: '0.0.0.0',
+                env: 'production',
+                watch: false,
+                cluster: true,
+                workers: parseInt(options.workers),
+                memory: parseInt(options.memory),
+                timeout: 30000,
+                gracefulTimeout: 10000,
+                verbose: options.verbose,
+                quiet: false,
+                color: false,
+                logLevel: 'warn',
+                nodeArgs: ['--optimize-for-size'],
+                inspect: false,
+                inspectPort: 9229,
+                pid: options.pid,
+                restart: true,
+                restartDelay: 2000,
+                maxRestarts: 5
+            });
+            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)} Deploy failed: ${error.message}`, 'error');
+            }
+            else {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown deploy error occurred`, 'error');
+            }
             process.exit(1);
         }
     });
-    return {
-        cleanupStart: async () => {
-            if (manager) {
-                await manager.stop();
+    // Health check command
+    program
+        .command('health [url]')
+        .description('Check server health')
+        .option('-t, --timeout <ms>', 'Request timeout in milliseconds', '5000')
+        .option('-i, --interval <ms>', 'Check interval in milliseconds', '1000')
+        .option('-c, --count <number>', 'Number of checks', '1')
+        .action(async (url, options) => {
+        const checkUrl = url || 'http://localhost:3000/health';
+        const timeout = parseInt(options.timeout);
+        const interval = parseInt(options.interval);
+        const count = parseInt(options.count);
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Health check: ${checkUrl}`, 'info');
+        for (let i = 0; i < count; i++) {
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), timeout);
+                const response = await fetch(checkUrl, {
+                    signal: controller.signal
+                });
+                clearTimeout(timeoutId);
+                if (response.ok) {
+                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Health check ${i + 1}/${count}: OK (${response.status})`, 'info');
+                }
+                else {
+                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Health check ${i + 1}/${count}: Failed (${response.status})`, 'error');
+                }
+            }
+            catch (error) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Health check ${i + 1}/${count}: Error (${error.message})`, 'error');
+            }
+            if (i < count - 1) {
+                await new Promise(resolve => setTimeout(resolve, interval));
+            }
+        }
+    });
+    // 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}, shutting down gracefully...`, '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('SIGQUIT', () => handleExit('SIGQUIT'));
+    // Handle uncaught exceptions
+    process.on('uncaughtException', (error) => {
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Uncaught exception: ${error.message}`, 'error');
+        cleanupStart().then(() => {
+            process.exit(1);
+        });
+    });
+    process.on('unhandledRejection', (reason, promise) => {
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Unhandled rejection at: ${promise} reason: ${reason}`, 'error');
+        cleanupStart().then(() => {
+            process.exit(1);
+        });
+    });
+    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();