neex 0.6.51 → 0.6.52

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

@@ -10,40 +10,31 @@ 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;
-    // Start command for production execution
+    // Single optimized start command for production
     program
         .command('start [file]')
-        .description('Start production application (default: dist/index.js)')
+        .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 (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('-p, --port <port>', 'Port number', parseInt)
+        .option('-w, --workers <count>', 'Number of worker processes (default: auto)', parseInt)
         .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('--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-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
+            // Auto-detect main file if not found
             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'));
@@ -51,155 +42,56 @@ function addStartCommands(program) {
                     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');
+                            logger_manager_js_1.loggerManager.printLine(`Using main file: ${mainFile}`, 'info');
                         }
                     }
                     else {
-                        throw new Error(`Neither ${targetFile} nor ${mainFile} found. Please build your project first.`);
+                        throw new Error(`Application file not found. Please build your project first.`);
                     }
                 }
                 else {
-                    throw new Error(`File not found: ${resolvedFile}. Please build your project first.`);
+                    throw new Error(`Application file not found: ${resolvedFile}`);
                 }
             }
-            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');
-            }
+            // 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({
                 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,
+                workers,
+                memoryLimit: isProduction ? '512M' : undefined,
+                logLevel: options.verbose ? 'debug' : 'info',
+                color: true,
                 verbose: options.verbose,
                 watch: options.watch,
-                maxMemory: options.maxMemory,
-                maxCrashes: options.maxCrashes,
-                restartDelay: options.restartDelay,
-                healthCheck: options.healthCheck,
+                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: 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(`${chalk_1.default.red(figures_1.default.cross)} An unknown start error occurred`, 'error');
-            }
-            process.exit(1);
-        }
-    });
-    // Quick start command
-    program
-        .command('run [file]')
-        .description('Quick start without options (alias for start)')
-        .action(async (file) => {
-        try {
-            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) {
             if (error instanceof Error) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Run 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 run error occurred`, 'error');
-            }
-            process.exit(1);
-        }
-    });
-    // 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');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Startup failed`, 'error');
             }
             process.exit(1);
         }
@@ -219,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}, stopping server...`, 'info');
             cleanupStart().then(() => {
                 process.exit(0);
             }).catch(() => {
@@ -233,12 +124,7 @@ function addStartCommands(program) {
     // 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();
-        }
-    });
+    process.on('SIGUSR2', () => handleExit('SIGUSR2'));
     return { cleanupStart };
 }
 exports.addStartCommands = addStartCommands;

package/dist/src/start-manager.js

@@ -4,11 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartManager = void 0;
-// src/start-manager.ts - Production start manager with clustering and monitoring
+// 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 fs_1 = __importDefault(require("fs"));
 const http_1 = __importDefault(require("http"));
@@ -16,43 +17,16 @@ const lodash_1 = require("lodash");
 class StartManager {
     constructor(options) {
         this.workers = new Map();
-        this.masterProcess = null;
         this.watcher = null;
         this.healthServer = null;
         this.isShuttingDown = false;
-        this.logStream = null;
         this.totalRestarts = 0;
         this.options = options;
         this.startTime = new Date();
         this.debouncedRestart = (0, lodash_1.debounce)(this.restartAll.bind(this), options.restartDelay);
-        this.setupLogging();
-    }
-    setupLogging() {
-        if (this.options.logFile) {
-            try {
-                const logDir = path_1.default.dirname(this.options.logFile);
-                if (!fs_1.default.existsSync(logDir)) {
-                    fs_1.default.mkdirSync(logDir, { recursive: true });
-                }
-                this.logStream = fs_1.default.createWriteStream(this.options.logFile, { flags: 'a' });
-                if (this.options.verbose) {
-                    logger_manager_js_1.loggerManager.printLine(`Logging to: ${this.options.logFile}`, 'info');
-                }
-            }
-            catch (error) {
-                logger_manager_js_1.loggerManager.printLine(`Failed to setup logging: ${error.message}`, 'warn');
-            }
-        }
     }
     log(message, level = 'info') {
-        const timestamp = new Date().toISOString();
-        const logMessage = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
-        if (this.logStream) {
-            this.logStream.write(logMessage + '\n');
-        }
-        if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(message, level);
-        }
+        logger_manager_js_1.loggerManager.printLine(message, level);
     }
     loadEnvFile() {
         if (this.options.envFile && fs_1.default.existsSync(this.options.envFile)) {
@@ -65,18 +39,16 @@ class StartManager {
                         const [key, ...values] = trimmed.split('=');
                         if (key && values.length > 0) {
                             const value = values.join('=').trim();
-                            // Remove quotes if present
                             const cleanValue = value.replace(/^["']|["']$/g, '');
                             process.env[key.trim()] = cleanValue;
                         }
                     }
                 }
-                if (this.options.verbose) {
-                    this.log(`Loaded environment variables from ${this.options.envFile}`);
-                }
             }
             catch (error) {
-                this.log(`Failed to load environment file: ${error.message}`, 'warn');
+                if (this.options.verbose) {
+                    this.log(`Failed to load environment file: ${error.message}`, 'warn');
+                }
             }
         }
     }
@@ -95,7 +67,8 @@ class StartManager {
     getNodeArgs() {
         const args = [];
         if (this.options.memoryLimit) {
-            args.push(`--max-old-space-size=${this.parseMemoryLimit(this.options.memoryLimit) / (1024 * 1024)}`);
+            const memoryMB = this.parseMemoryLimit(this.options.memoryLimit) / (1024 * 1024);
+            args.push(`--max-old-space-size=${memoryMB}`);
         }
         if (this.options.inspect) {
             args.push('--inspect');
@@ -125,32 +98,30 @@ class StartManager {
             cwd: this.options.workingDir,
             env,
             execArgv: nodeArgs,
-            silent: true
+            silent: false
         });
         const workerInfo = {
             process: workerProcess,
             pid: workerProcess.pid,
             restarts: 0,
-            startTime: new Date(),
-            memoryUsage: 0,
-            cpuUsage: 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) => {
-            if (!this.options.quiet) {
-                const message = data.toString().trim();
-                if (message) {
-                    console.log(chalk_1.default.dim(`[Worker ${workerId}]`) + ' ' + message);
-                }
+            const message = data.toString().trim();
+            if (message) {
+                console.log(this.options.verbose ?
+                    chalk_1.default.dim(`[Worker ${workerId}]`) + ' ' + message :
+                    message);
             }
         });
         (_b = workerProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
-            if (!this.options.quiet) {
-                const message = data.toString().trim();
-                if (message) {
-                    console.error(chalk_1.default.dim(`[Worker ${workerId}]`) + ' ' + chalk_1.default.red(message));
-                }
+            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));
             }
         });
         workerProcess.on('error', (error) => {
@@ -160,20 +131,14 @@ class StartManager {
             this.workers.delete(workerId);
             if (!this.isShuttingDown) {
                 if (code !== 0) {
-                    this.log(`Worker ${workerId} exited with code ${code}`, 'error');
+                    this.log(`Worker ${workerId} crashed (code: ${code})`, 'error');
                     this.restartWorker(workerId);
                 }
-                else {
-                    this.log(`Worker ${workerId} exited gracefully`);
-                }
             }
         });
-        workerProcess.on('message', (message) => {
-            if (this.options.verbose) {
-                this.log(`Worker ${workerId} message: ${JSON.stringify(message)}`);
-            }
-        });
-        this.log(`Started worker ${workerId} (PID: ${workerProcess.pid})`);
+        if (this.options.verbose) {
+            this.log(`Worker ${workerId} started (PID: ${workerProcess.pid})`);
+        }
         return workerInfo;
     }
     async restartWorker(workerId) {
@@ -182,11 +147,12 @@ class StartManager {
             workerInfo.restarts++;
             this.totalRestarts++;
             if (workerInfo.restarts >= this.options.maxCrashes) {
-                this.log(`Worker ${workerId} reached max crashes (${this.options.maxCrashes}), not restarting`, 'error');
+                this.log(`Worker ${workerId} reached max crashes, not restarting`, 'error');
                 return;
             }
-            this.log(`Restarting worker ${workerId} (restart #${workerInfo.restarts})`);
-            // Graceful shutdown
+            if (this.options.verbose) {
+                this.log(`Restarting worker ${workerId} (attempt ${workerInfo.restarts})`);
+            }
             try {
                 workerInfo.process.kill('SIGTERM');
                 await this.waitForProcessExit(workerInfo.process, 5000);
@@ -194,7 +160,6 @@ class StartManager {
             catch (error) {
                 workerInfo.process.kill('SIGKILL');
             }
-            // Start new worker
             setTimeout(() => {
                 this.startWorker(workerId);
             }, this.options.restartDelay);
@@ -211,49 +176,7 @@ class StartManager {
             });
         });
     }
-    async startSingleProcess() {
-        const nodeArgs = this.getNodeArgs();
-        const env = {
-            ...process.env,
-            NODE_ENV: process.env.NODE_ENV || 'production',
-            FORCE_COLOR: this.options.color ? '1' : '0'
-        };
-        if (this.options.port) {
-            env.PORT = this.options.port.toString();
-        }
-        this.masterProcess = (0, child_process_1.spawn)('node', [...nodeArgs, this.options.file], {
-            cwd: this.options.workingDir,
-            env,
-            stdio: this.options.quiet ? 'ignore' : 'inherit'
-        });
-        this.masterProcess.on('error', (error) => {
-            this.log(`Process error: ${error.message}`, 'error');
-        });
-        this.masterProcess.on('exit', (code, signal) => {
-            if (!this.isShuttingDown) {
-                if (code !== 0) {
-                    this.log(`Process exited with code ${code}`, 'error');
-                    if (this.totalRestarts < this.options.maxCrashes) {
-                        this.totalRestarts++;
-                        this.log(`Restarting process (restart #${this.totalRestarts})`);
-                        setTimeout(() => {
-                            this.startSingleProcess();
-                        }, this.options.restartDelay);
-                    }
-                    else {
-                        this.log(`Reached max crashes (${this.options.maxCrashes}), giving up`, 'error');
-                        process.exit(1);
-                    }
-                }
-                else {
-                    this.log('Process exited gracefully');
-                }
-            }
-        });
-        this.log(`Started process (PID: ${this.masterProcess.pid})`);
-    }
     async startCluster() {
-        this.log(`Starting cluster with ${this.options.workers} workers`);
         for (let i = 0; i < this.options.workers; i++) {
             await this.startWorker(i + 1);
         }
@@ -268,11 +191,10 @@ class StartManager {
                     uptime: Date.now() - this.startTime.getTime(),
                     workers: this.workers.size,
                     totalRestarts: this.totalRestarts,
-                    memoryUsage: process.memoryUsage(),
-                    cpuUsage: process.cpuUsage()
+                    memory: process.memoryUsage()
                 };
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify(stats, null, 2));
+                res.end(JSON.stringify(stats));
             }
             else {
                 res.writeHead(404);
@@ -280,7 +202,9 @@ class StartManager {
             }
         });
         this.healthServer.listen(this.options.healthPort, () => {
-            this.log(`Health check server listening on port ${this.options.healthPort}`);
+            if (this.options.verbose) {
+                this.log(`Health endpoint: http://localhost:${this.options.healthPort}/health`);
+            }
         });
     }
     setupWatcher() {
@@ -292,15 +216,8 @@ class StartManager {
             `${this.options.workingDir}/**/*.env*`
         ];
         this.watcher = (0, chokidar_1.watch)(watchPatterns, {
-            ignored: [
-                '**/node_modules/**',
-                '**/.git/**',
-                '**/logs/**',
-                '**/*.log'
-            ],
+            ignored: ['**/node_modules/**', '**/.git/**', '**/logs/**'],
             ignoreInitial: true,
-            followSymlinks: false,
-            usePolling: false,
             atomic: 300
         });
         this.watcher.on('change', (filePath) => {
@@ -309,94 +226,61 @@ class StartManager {
             }
             this.debouncedRestart();
         });
-        this.watcher.on('error', (error) => {
-            this.log(`Watcher error: ${error.message}`, 'error');
-        });
-        this.log('File watcher enabled');
+        if (this.options.verbose) {
+            this.log('File watching enabled');
+        }
     }
     async restartAll() {
         if (this.isShuttingDown)
             return;
-        this.log('Restarting all processes due to file changes');
-        if (this.options.cluster) {
-            // Graceful restart of workers
-            for (const [workerId, workerInfo] of this.workers.entries()) {
-                try {
-                    workerInfo.process.kill('SIGTERM');
-                    await this.waitForProcessExit(workerInfo.process, 5000);
-                }
-                catch (error) {
-                    workerInfo.process.kill('SIGKILL');
-                }
-                // Start new worker
-                setTimeout(() => {
-                    this.startWorker(workerId);
-                }, this.options.restartDelay);
-            }
-        }
-        else if (this.masterProcess) {
-            // Restart single process
+        this.log('Restarting due to file changes...');
+        for (const [workerId, workerInfo] of this.workers.entries()) {
             try {
-                this.masterProcess.kill('SIGTERM');
-                await this.waitForProcessExit(this.masterProcess, 5000);
+                workerInfo.process.kill('SIGTERM');
+                await this.waitForProcessExit(workerInfo.process, 5000);
             }
             catch (error) {
-                this.masterProcess.kill('SIGKILL');
+                workerInfo.process.kill('SIGKILL');
             }
             setTimeout(() => {
-                this.startSingleProcess();
+                this.startWorker(workerId);
             }, this.options.restartDelay);
         }
     }
-    setupMonitoring() {
+    setupMemoryMonitoring() {
+        if (!this.options.maxMemory)
+            return;
+        const maxMemory = this.parseMemoryLimit(this.options.maxMemory);
+        if (!maxMemory)
+            return;
         setInterval(() => {
-            if (this.options.verbose) {
-                this.workers.forEach((workerInfo, workerId) => {
-                    try {
-                        const usage = process.memoryUsage();
-                        workerInfo.memoryUsage = usage.heapUsed;
-                        if (this.options.maxMemory) {
-                            const maxMemory = this.parseMemoryLimit(this.options.maxMemory);
-                            if (maxMemory && usage.heapUsed > maxMemory) {
-                                this.log(`Worker ${workerId} exceeded memory limit, restarting`, 'warn');
-                                this.restartWorker(workerId);
-                            }
-                        }
-                    }
-                    catch (error) {
-                        // Ignore monitoring errors
+            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);
                     }
-                });
-            }
-        }, 10000); // Check every 10 seconds
+                }
+                catch (error) {
+                    // Ignore monitoring errors
+                }
+            });
+        }, 30000); // Check every 30 seconds
     }
     async start() {
         try {
             this.loadEnvFile();
             this.setupHealthCheck();
             this.setupWatcher();
-            this.setupMonitoring();
-            const runtime = Date.now() - this.startTime.getTime();
-            this.log(`Starting application in ${runtime}ms`);
-            if (this.options.cluster) {
-                await this.startCluster();
-            }
-            else {
-                await this.startSingleProcess();
-            }
-            this.log(`Application started successfully`);
-            if (this.options.verbose) {
-                this.log(`Configuration: ${JSON.stringify({
-                    workers: this.options.workers,
-                    cluster: this.options.cluster,
-                    watch: this.options.watch,
-                    healthCheck: this.options.healthCheck,
-                    port: this.options.port
-                })}`);
-            }
+            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) {
-            this.log(`Failed to start application: ${error.message}`, 'error');
             throw error;
         }
     }
@@ -404,18 +288,12 @@ class StartManager {
         if (this.isShuttingDown)
             return;
         this.isShuttingDown = true;
-        this.log('Stopping application...');
-        // Stop watcher
         if (this.watcher) {
             await this.watcher.close();
-            this.watcher = null;
         }
-        // Stop health server
         if (this.healthServer) {
             this.healthServer.close();
-            this.healthServer = null;
         }
-        // Stop all workers
         const shutdownPromises = [];
         for (const [workerId, workerInfo] of this.workers.entries()) {
             shutdownPromises.push((async () => {
@@ -428,29 +306,8 @@ class StartManager {
                 }
             })());
         }
-        // Stop master process
-        if (this.masterProcess) {
-            shutdownPromises.push((async () => {
-                try {
-                    this.masterProcess.kill('SIGTERM');
-                    await this.waitForProcessExit(this.masterProcess, this.options.gracefulTimeout);
-                }
-                catch (error) {
-                    this.masterProcess.kill('SIGKILL');
-                }
-            })());
-        }
-        // Wait for all processes to shut down
         await Promise.allSettled(shutdownPromises);
-        // Close log stream
-        if (this.logStream) {
-            this.logStream.end();
-            this.logStream = null;
-        }
-        const uptime = Date.now() - this.startTime.getTime();
-        this.log(`Application stopped after ${uptime}ms uptime`);
         this.workers.clear();
-        this.masterProcess = null;
     }
 }
 exports.StartManager = StartManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neex",
-  "version": "0.6.51",
+  "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",