neex 0.6.50 → 0.6.52

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

@@ -8,205 +8,94 @@ 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"));
 const os_1 = __importDefault(require("os"));
 function addStartCommands(program) {
     let startManager = null;
-    // Main start command
+    // Single optimized start command for production
     program
-        .command('start [entry]')
-        .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')
+        .command('start [file]')
+        .description('Start production application with automatic optimization')
+        .option('-d, --dir <directory>', 'Working directory', process.cwd())
+        .option('-e, --env <file>', 'Environment file to load', '.env')
+        .option('-p, --port <port>', 'Port number', parseInt)
+        .option('-w, --workers <count>', 'Number of worker processes (default: auto)', parseInt)
         .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('--watch', 'Watch for changes and restart (development mode)')
+        .option('--no-health', 'Disable health check endpoint')
+        .option('--health-port <port>', 'Health check port', parseInt, 3001)
+        .option('--max-memory <limit>', 'Maximum memory before restart (e.g., 1G)')
+        .option('--graceful-timeout <ms>', 'Graceful shutdown timeout (ms)', parseInt, 30000)
         .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) => {
+        .option('--inspect-brk', 'Enable Node.js inspector with break')
+        .action(async (file, options) => {
         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(`${chalk_1.default.red(figures_1.default.cross)} An unknown start error occurred`, 'error');
+            const targetFile = file || 'dist/index.js';
+            const resolvedFile = path_1.default.resolve(options.dir, targetFile);
+            // Auto-detect main file if not found
+            if (!fs_1.default.existsSync(resolvedFile)) {
+                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: ${mainFile}`, 'info');
+                        }
+                    }
+                    else {
+                        throw new Error(`Application file not found. Please build your project first.`);
+                    }
+                }
+                else {
+                    throw new Error(`Application file not found: ${resolvedFile}`);
+                }
             }
-            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');
+            // Auto-detect optimal configuration
+            const isDevelopment = options.watch || process.env.NODE_ENV === 'development';
+            const isProduction = !isDevelopment;
+            const cpuCount = os_1.default.cpus().length;
+            const workers = options.workers || (isProduction ? cpuCount : 1);
+            const healthCheck = options.health !== false && isProduction;
+            // Startup logging
+            const mode = isDevelopment ? 'development' : 'production';
+            const clusterInfo = workers > 1 ? ` (${workers} workers)` : '';
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.play)} Starting ${mode} server${clusterInfo}`, '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,
+                file: resolvedFile,
+                workingDir: options.dir,
+                envFile: options.env,
+                port: options.port,
+                workers,
+                memoryLimit: isProduction ? '512M' : undefined,
+                logLevel: options.verbose ? 'debug' : 'info',
                 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);
-        }
-    });
-    // 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 {
-            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
+                watch: options.watch,
+                maxMemory: options.maxMemory || (isProduction ? '1G' : undefined),
+                maxCrashes: isProduction ? 3 : 5,
+                restartDelay: isProduction ? 2000 : 1000,
+                healthCheck,
+                healthPort: options.healthPort,
+                gracefulTimeout: options.gracefulTimeout,
+                inspect: options.inspect,
+                inspectBrk: options.inspectBrk,
+                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)} Deploy failed: ${error.message}`, 'error');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} ${error.message}`, 'error');
             }
             else {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown deploy error occurred`, 'error');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Startup failed`, 'error');
             }
             process.exit(1);
         }
     });
-    // 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) {
@@ -222,7 +111,6 @@ function addStartCommands(program) {
     // 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(() => {
@@ -236,20 +124,7 @@ function addStartCommands(program) {
     // 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);
-        });
-    });
+    process.on('SIGUSR2', () => handleExit('SIGUSR2'));
     return { cleanupStart };
 }
 exports.addStartCommands = addStartCommands;

package/dist/src/start-manager.js

@@ -4,407 +4,310 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartManager = void 0;
-// src/start-manager.ts - Production server manager for built TypeScript projects
+// src/start-manager.ts - Optimized production start manager
 const child_process_1 = require("child_process");
 const chokidar_1 = require("chokidar");
 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 promises_1 = __importDefault(require("fs/promises"));
-const fs_1 = require("fs");
-const perf_hooks_1 = require("perf_hooks");
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const lodash_1 = require("lodash");
 class StartManager {
     constructor(options) {
-        this.serverProcess = null;
+        this.workers = new Map();
         this.watcher = null;
-        this.isStarting = false;
-        this.restartCount = 0;
-        this.startTime = 0;
+        this.healthServer = null;
         this.isShuttingDown = false;
-        this.restartTimer = null;
+        this.totalRestarts = 0;
         this.options = options;
+        this.startTime = new Date();
+        this.debouncedRestart = (0, lodash_1.debounce)(this.restartAll.bind(this), options.restartDelay);
     }
-    async validateEntry() {
-        let entryPath = this.options.entry;
-        // Check if entry exists as provided
-        if ((0, fs_1.existsSync)(entryPath)) {
-            return path_1.default.resolve(entryPath);
-        }
-        // Try with .js extension
-        if (!entryPath.endsWith('.js')) {
-            const jsPath = entryPath + '.js';
-            if ((0, fs_1.existsSync)(jsPath)) {
-                return path_1.default.resolve(jsPath);
-            }
-        }
-        // Try in dist directory
-        const distPath = path_1.default.join('dist', entryPath);
-        if ((0, fs_1.existsSync)(distPath)) {
-            return path_1.default.resolve(distPath);
-        }
-        // Try in dist with .js extension
-        if (!entryPath.endsWith('.js')) {
-            const distJsPath = path_1.default.join('dist', entryPath + '.js');
-            if ((0, fs_1.existsSync)(distJsPath)) {
-                return path_1.default.resolve(distJsPath);
+    log(message, level = 'info') {
+        logger_manager_js_1.loggerManager.printLine(message, level);
+    }
+    loadEnvFile() {
+        if (this.options.envFile && fs_1.default.existsSync(this.options.envFile)) {
+            try {
+                const envContent = fs_1.default.readFileSync(this.options.envFile, 'utf8');
+                const lines = envContent.split('\n');
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (trimmed && !trimmed.startsWith('#')) {
+                        const [key, ...values] = trimmed.split('=');
+                        if (key && values.length > 0) {
+                            const value = values.join('=').trim();
+                            const cleanValue = value.replace(/^["']|["']$/g, '');
+                            process.env[key.trim()] = cleanValue;
+                        }
+                    }
+                }
             }
-        }
-        // Try common entry points
-        const commonEntries = [
-            'dist/index.js',
-            'dist/server.js',
-            'dist/app.js',
-            'dist/main.js',
-            'index.js',
-            'server.js'
-        ];
-        for (const entry of commonEntries) {
-            if ((0, fs_1.existsSync)(entry)) {
-                if (!this.options.quiet) {
-                    logger_manager_js_1.loggerManager.printLine(`Using entry point: ${entry}`, 'info');
+            catch (error) {
+                if (this.options.verbose) {
+                    this.log(`Failed to load environment file: ${error.message}`, 'warn');
                 }
-                return path_1.default.resolve(entry);
             }
         }
-        throw new Error(`Entry file not found: ${entryPath}`);
     }
-    async loadPackageJson() {
-        try {
-            const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
-            if ((0, fs_1.existsSync)(packageJsonPath)) {
-                const content = await promises_1.default.readFile(packageJsonPath, 'utf8');
-                return JSON.parse(content);
-            }
-        }
-        catch (error) {
-            // Ignore package.json errors
-        }
-        return null;
+    parseMemoryLimit(limit) {
+        var _a;
+        if (!limit)
+            return undefined;
+        const match = limit.match(/^(\d+)([KMGT]?)$/i);
+        if (!match)
+            return undefined;
+        const value = parseInt(match[1]);
+        const unit = ((_a = match[2]) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || '';
+        const multipliers = { K: 1024, M: 1024 * 1024, G: 1024 * 1024 * 1024, T: 1024 * 1024 * 1024 * 1024 };
+        return value * (multipliers[unit] || 1);
     }
     getNodeArgs() {
         const args = [];
-        // Add custom node arguments
-        if (this.options.nodeArgs.length > 0) {
-            args.push(...this.options.nodeArgs);
+        if (this.options.memoryLimit) {
+            const memoryMB = this.parseMemoryLimit(this.options.memoryLimit) / (1024 * 1024);
+            args.push(`--max-old-space-size=${memoryMB}`);
         }
-        // Memory limit
-        if (this.options.memory > 0) {
-            args.push(`--max-old-space-size=${this.options.memory}`);
-        }
-        // Debugging
         if (this.options.inspect) {
-            args.push(`--inspect=${this.options.inspectPort}`);
+            args.push('--inspect');
+        }
+        if (this.options.inspectBrk) {
+            args.push('--inspect-brk');
         }
-        // Production optimizations
-        if (this.options.env === 'production') {
-            args.push('--optimize-for-size');
+        if (this.options.nodeArgs) {
+            args.push(...this.options.nodeArgs.split(' '));
         }
         return args;
     }
-    getEnvironment() {
+    async startWorker(workerId) {
+        var _a, _b;
+        const nodeArgs = this.getNodeArgs();
         const env = {
             ...process.env,
-            NODE_ENV: this.options.env,
-            PORT: this.options.port.toString(),
-            HOST: this.options.host,
-            LOG_LEVEL: this.options.logLevel
+            NODE_ENV: process.env.NODE_ENV || 'production',
+            WORKER_ID: workerId.toString(),
+            CLUSTER_WORKER: 'true',
+            FORCE_COLOR: this.options.color ? '1' : '0'
         };
-        // Add color support
-        if (this.options.color) {
-            env.FORCE_COLOR = '1';
+        if (this.options.port) {
+            env.PORT = this.options.port.toString();
         }
-        return env;
-    }
-    async writePidFile(pid) {
-        if (this.options.pid) {
-            try {
-                await promises_1.default.writeFile(this.options.pid, pid.toString());
-                if (this.options.verbose) {
-                    logger_manager_js_1.loggerManager.printLine(`PID file written: ${this.options.pid}`, 'info');
-                }
+        const workerProcess = (0, child_process_1.fork)(this.options.file, [], {
+            cwd: this.options.workingDir,
+            env,
+            execArgv: nodeArgs,
+            silent: false
+        });
+        const workerInfo = {
+            process: workerProcess,
+            pid: workerProcess.pid,
+            restarts: 0,
+            startTime: new Date()
+        };
+        this.workers.set(workerId, workerInfo);
+        // Handle worker output
+        (_a = workerProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+            const message = data.toString().trim();
+            if (message) {
+                console.log(this.options.verbose ?
+                    chalk_1.default.dim(`[Worker ${workerId}]`) + ' ' + message :
+                    message);
             }
-            catch (error) {
-                logger_manager_js_1.loggerManager.printLine(`Failed to write PID file: ${error.message}`, 'warn');
+        });
+        (_b = workerProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+            const message = data.toString().trim();
+            if (message) {
+                console.error(this.options.verbose ?
+                    chalk_1.default.dim(`[Worker ${workerId}]`) + ' ' + chalk_1.default.red(message) :
+                    chalk_1.default.red(message));
             }
-        }
-    }
-    async removePidFile() {
-        if (this.options.pid && (0, fs_1.existsSync)(this.options.pid)) {
-            try {
-                await promises_1.default.unlink(this.options.pid);
-                if (this.options.verbose) {
-                    logger_manager_js_1.loggerManager.printLine(`PID file removed: ${this.options.pid}`, 'info');
+        });
+        workerProcess.on('error', (error) => {
+            this.log(`Worker ${workerId} error: ${error.message}`, 'error');
+        });
+        workerProcess.on('exit', (code, signal) => {
+            this.workers.delete(workerId);
+            if (!this.isShuttingDown) {
+                if (code !== 0) {
+                    this.log(`Worker ${workerId} crashed (code: ${code})`, 'error');
+                    this.restartWorker(workerId);
                 }
             }
-            catch (error) {
-                // Ignore cleanup errors
-            }
+        });
+        if (this.options.verbose) {
+            this.log(`Worker ${workerId} started (PID: ${workerProcess.pid})`);
         }
+        return workerInfo;
     }
-    async startServer() {
-        if (this.isStarting || this.isShuttingDown) {
-            return;
-        }
-        this.isStarting = true;
-        this.startTime = perf_hooks_1.performance.now();
-        try {
-            const entryPath = await this.validateEntry();
-            const nodeArgs = this.getNodeArgs();
-            const env = this.getEnvironment();
-            if (!this.options.quiet) {
-                const restartInfo = this.restartCount > 0 ? ` (restart #${this.restartCount})` : '';
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting server${restartInfo}...`, 'info');
-                if (this.options.verbose) {
-                    logger_manager_js_1.loggerManager.printLine(`Entry: ${entryPath}`, 'info');
-                    logger_manager_js_1.loggerManager.printLine(`Environment: ${this.options.env}`, 'info');
-                    logger_manager_js_1.loggerManager.printLine(`Host: ${this.options.host}:${this.options.port}`, 'info');
-                    if (nodeArgs.length > 0) {
-                        logger_manager_js_1.loggerManager.printLine(`Node args: ${nodeArgs.join(' ')}`, 'info');
-                    }
-                }
-            }
-            const args = [...nodeArgs, entryPath];
-            this.serverProcess = (0, child_process_1.spawn)('node', args, {
-                stdio: this.options.verbose ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'ignore', 'pipe'],
-                env,
-                detached: false,
-                cwd: process.cwd()
-            });
-            if (this.serverProcess.pid) {
-                await this.writePidFile(this.serverProcess.pid);
+    async restartWorker(workerId) {
+        const workerInfo = this.workers.get(workerId);
+        if (workerInfo) {
+            workerInfo.restarts++;
+            this.totalRestarts++;
+            if (workerInfo.restarts >= this.options.maxCrashes) {
+                this.log(`Worker ${workerId} reached max crashes, not restarting`, 'error');
+                return;
             }
-            // Handle server output
-            if (this.options.verbose && this.serverProcess.stdout) {
-                this.serverProcess.stdout.on('data', (data) => {
-                    const output = data.toString().trim();
-                    if (output) {
-                        logger_manager_js_1.loggerManager.printLine(`[SERVER] ${output}`, 'info');
-                    }
-                });
+            if (this.options.verbose) {
+                this.log(`Restarting worker ${workerId} (attempt ${workerInfo.restarts})`);
             }
-            // Handle server errors
-            if (this.serverProcess.stderr) {
-                this.serverProcess.stderr.on('data', (data) => {
-                    const error = data.toString().trim();
-                    if (error && !this.options.quiet) {
-                        logger_manager_js_1.loggerManager.printLine(`[SERVER] ${error}`, 'error');
-                    }
-                });
+            try {
+                workerInfo.process.kill('SIGTERM');
+                await this.waitForProcessExit(workerInfo.process, 5000);
             }
-            // Handle process events
-            this.serverProcess.on('error', (error) => {
-                this.isStarting = false;
-                if (!this.isShuttingDown) {
-                    logger_manager_js_1.loggerManager.printLine(`Server process error: ${error.message}`, 'error');
-                    this.handleServerExit(1);
-                }
-            });
-            this.serverProcess.on('exit', (code, signal) => {
-                this.isStarting = false;
-                if (!this.isShuttingDown) {
-                    this.handleServerExit(code || 0, signal || undefined);
-                }
-            });
-            // Wait for server to start
-            await this.waitForServerStart();
-            this.isStarting = false;
-            const duration = Math.round(perf_hooks_1.performance.now() - this.startTime);
-            if (!this.options.quiet) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Server started successfully in ${duration}ms`, 'info');
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Running on ${chalk_1.default.cyan(`http://${this.options.host}:${this.options.port}`)}`, 'info');
+            catch (error) {
+                workerInfo.process.kill('SIGKILL');
             }
-        }
-        catch (error) {
-            this.isStarting = false;
-            throw error;
+            setTimeout(() => {
+                this.startWorker(workerId);
+            }, this.options.restartDelay);
         }
     }
-    async waitForServerStart() {
+    async waitForProcessExit(process, timeout) {
         return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error(`Server startup timeout after ${this.options.timeout}ms`));
-            }, this.options.timeout);
-            if (this.serverProcess) {
-                // If process exits immediately, it's likely an error
-                const exitHandler = (code) => {
-                    clearTimeout(timeout);
-                    if (code !== 0) {
-                        reject(new Error(`Server exited with code ${code}`));
-                    }
-                    else {
-                        resolve();
-                    }
+            const timer = setTimeout(() => {
+                reject(new Error('Process exit timeout'));
+            }, timeout);
+            process.on('exit', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+    }
+    async startCluster() {
+        for (let i = 0; i < this.options.workers; i++) {
+            await this.startWorker(i + 1);
+        }
+    }
+    setupHealthCheck() {
+        if (!this.options.healthCheck)
+            return;
+        this.healthServer = http_1.default.createServer((req, res) => {
+            if (req.url === '/health') {
+                const stats = {
+                    status: 'ok',
+                    uptime: Date.now() - this.startTime.getTime(),
+                    workers: this.workers.size,
+                    totalRestarts: this.totalRestarts,
+                    memory: process.memoryUsage()
                 };
-                this.serverProcess.once('exit', exitHandler);
-                // Give some time for the server to start
-                setTimeout(() => {
-                    if (this.serverProcess && !this.serverProcess.killed) {
-                        this.serverProcess.removeListener('exit', exitHandler);
-                        clearTimeout(timeout);
-                        resolve();
-                    }
-                }, 1000);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(stats));
             }
             else {
-                clearTimeout(timeout);
-                reject(new Error('Server process not created'));
+                res.writeHead(404);
+                res.end('Not Found');
+            }
+        });
+        this.healthServer.listen(this.options.healthPort, () => {
+            if (this.options.verbose) {
+                this.log(`Health endpoint: http://localhost:${this.options.healthPort}/health`);
             }
         });
-    }
-    handleServerExit(code, signal) {
-        this.removePidFile();
-        if (this.isShuttingDown) {
-            return;
-        }
-        const exitMessage = signal
-            ? `Server process killed with signal ${signal}`
-            : `Server process exited with code ${code}`;
-        if (code !== 0 && !this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} ${exitMessage}`, 'error');
-        }
-        // Handle restart logic
-        if (this.options.restart && code !== 0 && this.restartCount < this.options.maxRestarts) {
-            this.scheduleRestart();
-        }
-        else if (this.restartCount >= this.options.maxRestarts) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Maximum restart attempts reached (${this.options.maxRestarts})`, 'error');
-            process.exit(1);
-        }
-        else if (code !== 0) {
-            process.exit(code);
-        }
-    }
-    scheduleRestart() {
-        this.restartCount++;
-        const delay = this.options.restartDelay * Math.min(this.restartCount, 5); // Exponential backoff
-        if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Restarting server in ${delay}ms... (${this.restartCount}/${this.options.maxRestarts})`, 'info');
-        }
-        this.restartTimer = setTimeout(() => {
-            this.restartTimer = null;
-            this.startServer().catch(error => {
-                logger_manager_js_1.loggerManager.printLine(`Restart failed: ${error.message}`, 'error');
-                this.handleServerExit(1);
-            });
-        }, delay);
     }
     setupWatcher() {
         if (!this.options.watch)
             return;
         const watchPatterns = [
-            'dist/**/*.js',
-            'package.json',
-            'dist/package.json'
+            `${this.options.workingDir}/**/*.js`,
+            `${this.options.workingDir}/**/*.json`,
+            `${this.options.workingDir}/**/*.env*`
         ];
         this.watcher = (0, chokidar_1.watch)(watchPatterns, {
+            ignored: ['**/node_modules/**', '**/.git/**', '**/logs/**'],
             ignoreInitial: true,
-            followSymlinks: false,
-            usePolling: false,
-            atomic: 500,
-            ignored: [
-                '**/node_modules/**',
-                '**/.git/**',
-                '**/*.log',
-                '**/*.map'
-            ]
+            atomic: 300
         });
         this.watcher.on('change', (filePath) => {
             if (this.options.verbose) {
-                logger_manager_js_1.loggerManager.printLine(`File changed: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+                this.log(`File changed: ${path_1.default.relative(this.options.workingDir, filePath)}`);
             }
-            this.restart();
-        });
-        this.watcher.on('error', (error) => {
-            logger_manager_js_1.loggerManager.printLine(`Watcher error: ${error.message}`, 'error');
+            this.debouncedRestart();
         });
         if (this.options.verbose) {
-            logger_manager_js_1.loggerManager.printLine(`Watching: ${watchPatterns.join(', ')}`, 'info');
+            this.log('File watching enabled');
         }
     }
-    async restart() {
+    async restartAll() {
         if (this.isShuttingDown)
             return;
-        if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Restarting server...`, 'info');
-        }
-        await this.stopServer();
-        // Small delay before restart
-        setTimeout(() => {
-            this.startServer().catch(error => {
-                logger_manager_js_1.loggerManager.printLine(`Restart failed: ${error.message}`, 'error');
-                process.exit(1);
-            });
-        }, 100);
-    }
-    async stopServer() {
-        if (!this.serverProcess)
-            return;
-        return new Promise((resolve) => {
-            if (!this.serverProcess) {
-                resolve();
-                return;
-            }
-            const proc = this.serverProcess;
-            this.serverProcess = null;
-            if (this.restartTimer) {
-                clearTimeout(this.restartTimer);
-                this.restartTimer = null;
-            }
-            const cleanup = () => {
-                this.removePidFile();
-                resolve();
-            };
-            proc.on('exit', cleanup);
-            proc.on('error', cleanup);
+        this.log('Restarting due to file changes...');
+        for (const [workerId, workerInfo] of this.workers.entries()) {
             try {
-                if (proc.pid) {
-                    // Graceful shutdown
-                    proc.kill('SIGTERM');
-                    // Force kill after timeout
-                    setTimeout(() => {
-                        if (proc.pid && !proc.killed) {
-                            try {
-                                proc.kill('SIGKILL');
-                            }
-                            catch (e) {
-                                // Ignore
-                            }
-                        }
-                    }, this.options.gracefulTimeout);
-                }
+                workerInfo.process.kill('SIGTERM');
+                await this.waitForProcessExit(workerInfo.process, 5000);
             }
             catch (error) {
-                cleanup();
+                workerInfo.process.kill('SIGKILL');
             }
-        });
+            setTimeout(() => {
+                this.startWorker(workerId);
+            }, this.options.restartDelay);
+        }
+    }
+    setupMemoryMonitoring() {
+        if (!this.options.maxMemory)
+            return;
+        const maxMemory = this.parseMemoryLimit(this.options.maxMemory);
+        if (!maxMemory)
+            return;
+        setInterval(() => {
+            this.workers.forEach((workerInfo, workerId) => {
+                try {
+                    const usage = process.memoryUsage();
+                    if (usage.heapUsed > maxMemory) {
+                        this.log(`Worker ${workerId} exceeded memory limit, restarting`, 'warn');
+                        this.restartWorker(workerId);
+                    }
+                }
+                catch (error) {
+                    // Ignore monitoring errors
+                }
+            });
+        }, 30000); // Check every 30 seconds
     }
     async start() {
         try {
-            await this.startServer();
+            this.loadEnvFile();
+            this.setupHealthCheck();
             this.setupWatcher();
-            if (this.options.watch && !this.options.quiet) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Watching for changes...`, 'info');
-            }
+            this.setupMemoryMonitoring();
+            await this.startCluster();
+            // Success message
+            const port = this.options.port || process.env.PORT;
+            const portInfo = port ? ` on port ${port}` : '';
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Server ready${portInfo}`, 'info');
         }
         catch (error) {
-            logger_manager_js_1.loggerManager.printLine(`Failed to start server: ${error.message}`, 'error');
-            process.exit(1);
+            throw error;
         }
     }
     async stop() {
+        if (this.isShuttingDown)
+            return;
         this.isShuttingDown = true;
-        if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Stopping server...`, 'info');
-        }
         if (this.watcher) {
             await this.watcher.close();
-            this.watcher = null;
         }
-        await this.stopServer();
-        if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Server stopped successfully`, 'info');
+        if (this.healthServer) {
+            this.healthServer.close();
+        }
+        const shutdownPromises = [];
+        for (const [workerId, workerInfo] of this.workers.entries()) {
+            shutdownPromises.push((async () => {
+                try {
+                    workerInfo.process.kill('SIGTERM');
+                    await this.waitForProcessExit(workerInfo.process, this.options.gracefulTimeout);
+                }
+                catch (error) {
+                    workerInfo.process.kill('SIGKILL');
+                }
+            })());
         }
+        await Promise.allSettled(shutdownPromises);
+        this.workers.clear();
     }
 }
 exports.StartManager = StartManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neex",
-  "version": "0.6.50",
+  "version": "0.6.52",
   "description": "The Modern Build System for Polyrepo-in-Monorepo Architecture",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",