neex 0.6.52 → 0.6.55

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

@@ -13,10 +13,10 @@ const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 function addStartCommands(program) {
     let startManager = null;
-    // Single optimized start command for production
+    // Production start command
     program
         .command('start [file]')
-        .description('Start production application with automatic optimization')
+        .description('Start production application')
         .option('-d, --dir <directory>', 'Working directory', process.cwd())
         .option('-e, --env <file>', 'Environment file to load', '.env')
         .option('-p, --port <port>', 'Port number', parseInt)
@@ -29,60 +29,119 @@ function addStartCommands(program) {
         .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);
+            const targetFile = file || 'dist/server.js';
+            let 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');
+                    try {
+                        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)) {
+                            resolvedFile = alternativeFile;
+                            if (options.verbose) {
+                                logger_manager_js_1.loggerManager.printLine(`Using main file: ${mainFile}`, 'info');
+                            }
+                        }
+                        else {
+                            // Try common locations
+                            const commonLocations = [
+                                'dist/server.js',
+                                'dist/app.js',
+                                'dist/index.js',
+                                'build/server.js',
+                                'build/app.js',
+                                'build/index.js',
+                                'server.js',
+                                'app.js',
+                                'index.js'
+                            ];
+                            let found = false;
+                            for (const location of commonLocations) {
+                                const testPath = path_1.default.resolve(options.dir, location);
+                                if (fs_1.default.existsSync(testPath)) {
+                                    resolvedFile = testPath;
+                                    found = true;
+                                    if (options.verbose) {
+                                        logger_manager_js_1.loggerManager.printLine(`Found application file: ${location}`, 'info');
+                                    }
+                                    break;
+                                }
+                            }
+                            if (!found) {
+                                throw new Error(`Application file not found. Tried: ${targetFile}, ${mainFile}, and common locations.`);
+                            }
                         }
                     }
-                    else {
-                        throw new Error(`Application file not found. Please build your project first.`);
+                    catch (parseError) {
+                        throw new Error(`Failed to parse package.json: ${parseError.message}`);
                     }
                 }
                 else {
                     throw new Error(`Application file not found: ${resolvedFile}`);
                 }
             }
-            // Auto-detect optimal configuration
+            // Environment detection
             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;
+            // Smart worker allocation
+            let workers = options.workers;
+            if (!workers) {
+                if (isDevelopment) {
+                    workers = 1;
+                }
+                else {
+                    // For production, use CPU count but cap at reasonable limit
+                    workers = Math.min(cpuCount, 4); // Reduced from 8 to 4 for better resource management
+                }
+            }
+            const healthCheck = options.health !== false;
+            const defaultPort = parseInt(process.env.PORT || '8000');
+            const port = options.port || defaultPort;
+            // Set NODE_ENV if not already set
+            if (!process.env.NODE_ENV) {
+                process.env.NODE_ENV = isProduction ? 'production' : 'development';
+            }
             // 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');
+            if (options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`File: ${path_1.default.relative(process.cwd(), resolvedFile)}`);
+                logger_manager_js_1.loggerManager.printLine(`Working Directory: ${options.dir}`);
+                logger_manager_js_1.loggerManager.printLine(`Environment: ${process.env.NODE_ENV}`);
+                logger_manager_js_1.loggerManager.printLine(`Port: ${port}`);
+                logger_manager_js_1.loggerManager.printLine(`Workers: ${workers}`);
+                if (healthCheck) {
+                    logger_manager_js_1.loggerManager.printLine(`Health Check: http://localhost:${options.healthPort}/health`);
+                }
+            }
             startManager = new start_manager_js_1.StartManager({
                 file: resolvedFile,
                 workingDir: options.dir,
                 envFile: options.env,
-                port: options.port,
+                port,
                 workers,
                 memoryLimit: isProduction ? '512M' : undefined,
                 logLevel: options.verbose ? 'debug' : 'info',
-                color: true,
+                color: process.stdout.isTTY,
                 verbose: options.verbose,
                 watch: options.watch,
                 maxMemory: options.maxMemory || (isProduction ? '1G' : undefined),
-                maxCrashes: isProduction ? 3 : 5,
-                restartDelay: isProduction ? 2000 : 1000,
+                maxCrashes: isProduction ? 3 : 10,
+                restartDelay: isProduction ? 1000 : 500,
                 healthCheck,
                 healthPort: options.healthPort,
                 gracefulTimeout: options.gracefulTimeout,
                 inspect: options.inspect,
                 inspectBrk: options.inspectBrk,
-                nodeArgs: undefined
+                nodeArgs: options.nodeArgs
             });
             await startManager.start();
         }
@@ -104,13 +163,16 @@ function addStartCommands(program) {
                 startManager = null;
             }
             catch (error) {
-                // Ignore cleanup errors
+                if (process.env.VERBOSE) {
+                    console.error('Cleanup error:', error);
+                }
             }
         }
     };
-    // Handle process termination
+    // Signal handling
     const handleExit = (signal) => {
         if (startManager) {
+            console.log(`\n${chalk_1.default.yellow(figures_1.default.warning)} Received ${signal}, shutting down gracefully...`);
             cleanupStart().then(() => {
                 process.exit(0);
             }).catch(() => {
@@ -121,10 +183,21 @@ function addStartCommands(program) {
             process.exit(0);
         }
     };
-    // Register signal handlers
     process.on('SIGINT', () => handleExit('SIGINT'));
     process.on('SIGTERM', () => handleExit('SIGTERM'));
     process.on('SIGUSR2', () => handleExit('SIGUSR2'));
+    process.on('uncaughtException', (error) => {
+        console.error(`${chalk_1.default.red(figures_1.default.cross)} Uncaught Exception:`, error);
+        cleanupStart().then(() => {
+            process.exit(1);
+        });
+    });
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error(`${chalk_1.default.red(figures_1.default.cross)} Unhandled Rejection at:`, promise, 'reason:', reason);
+        cleanupStart().then(() => {
+            process.exit(1);
+        });
+    });
     return { cleanupStart };
 }
 exports.addStartCommands = addStartCommands;

package/dist/src/start-manager.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartManager = void 0;
-// src/start-manager.ts - Optimized production start manager
+// src/start-manager.ts - Fixed production start manager
 const child_process_1 = require("child_process");
 const chokidar_1 = require("chokidar");
 const logger_manager_js_1 = require("./logger-manager.js");
@@ -14,6 +14,7 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const http_1 = __importDefault(require("http"));
 const lodash_1 = require("lodash");
+const os_1 = __importDefault(require("os"));
 class StartManager {
     constructor(options) {
         this.workers = new Map();
@@ -21,6 +22,8 @@ class StartManager {
         this.healthServer = null;
         this.isShuttingDown = false;
         this.totalRestarts = 0;
+        this.envLoaded = false;
+        this.masterProcess = null;
         this.options = options;
         this.startTime = new Date();
         this.debouncedRestart = (0, lodash_1.debounce)(this.restartAll.bind(this), options.restartDelay);
@@ -29,10 +32,13 @@ class StartManager {
         logger_manager_js_1.loggerManager.printLine(message, level);
     }
     loadEnvFile() {
+        if (this.envLoaded)
+            return;
         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');
+                let loadedCount = 0;
                 for (const line of lines) {
                     const trimmed = line.trim();
                     if (trimmed && !trimmed.startsWith('#')) {
@@ -40,10 +46,17 @@ class StartManager {
                         if (key && values.length > 0) {
                             const value = values.join('=').trim();
                             const cleanValue = value.replace(/^["']|["']$/g, '');
-                            process.env[key.trim()] = cleanValue;
+                            if (!process.env[key.trim()]) {
+                                process.env[key.trim()] = cleanValue;
+                                loadedCount++;
+                            }
                         }
                     }
                 }
+                if (this.options.verbose && loadedCount > 0) {
+                    this.log(`Loaded ${loadedCount} environment variables from ${this.options.envFile}`);
+                }
+                this.envLoaded = true;
             }
             catch (error) {
                 if (this.options.verbose) {
@@ -67,8 +80,11 @@ class StartManager {
     getNodeArgs() {
         const args = [];
         if (this.options.memoryLimit) {
-            const memoryMB = this.parseMemoryLimit(this.options.memoryLimit) / (1024 * 1024);
-            args.push(`--max-old-space-size=${memoryMB}`);
+            const memoryBytes = this.parseMemoryLimit(this.options.memoryLimit);
+            if (memoryBytes) {
+                const memoryMB = Math.floor(memoryBytes / (1024 * 1024));
+                args.push(`--max-old-space-size=${memoryMB}`);
+            }
         }
         if (this.options.inspect) {
             args.push('--inspect');
@@ -77,51 +93,115 @@ class StartManager {
             args.push('--inspect-brk');
         }
         if (this.options.nodeArgs) {
-            args.push(...this.options.nodeArgs.split(' '));
+            args.push(...this.options.nodeArgs.split(' ').filter(arg => arg.trim()));
         }
         return args;
     }
+    async startSingleProcess() {
+        const nodeArgs = this.getNodeArgs();
+        const port = this.options.port || 8000;
+        const env = {
+            ...process.env,
+            NODE_ENV: process.env.NODE_ENV || 'production',
+            PORT: port.toString(),
+            FORCE_COLOR: this.options.color ? '1' : '0',
+            NODE_OPTIONS: '--no-deprecation'
+        };
+        this.masterProcess = (0, child_process_1.fork)(this.options.file, [], {
+            cwd: this.options.workingDir,
+            env,
+            execArgv: nodeArgs,
+            silent: false // Let the process handle its own output
+        });
+        this.masterProcess.on('error', (error) => {
+            this.log(`Process error: ${error.message}`, 'error');
+        });
+        this.masterProcess.on('exit', (code, signal) => {
+            if (!this.isShuttingDown && code !== 0 && signal !== 'SIGTERM') {
+                this.log(`Process crashed (code: ${code}, signal: ${signal})`, 'error');
+                this.totalRestarts++;
+                if (this.totalRestarts < this.options.maxCrashes) {
+                    setTimeout(() => {
+                        this.startSingleProcess();
+                    }, this.options.restartDelay);
+                }
+                else {
+                    this.log(`Max crashes reached (${this.options.maxCrashes}), not restarting`, 'error');
+                }
+            }
+        });
+        // Wait for process to be ready
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                resolve(); // Don't reject, assume it's ready
+            }, 5000);
+            this.masterProcess.on('message', (message) => {
+                if (message && message.type === 'ready') {
+                    clearTimeout(timeout);
+                    resolve();
+                }
+            });
+            this.masterProcess.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+            this.masterProcess.on('exit', (code) => {
+                clearTimeout(timeout);
+                if (code !== 0) {
+                    reject(new Error(`Process exited with code ${code}`));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        if (this.options.verbose) {
+            this.log(`Process started (PID: ${this.masterProcess.pid}, Port: ${port})`);
+        }
+    }
     async startWorker(workerId) {
         var _a, _b;
         const nodeArgs = this.getNodeArgs();
+        const port = this.options.port || 8000;
         const env = {
             ...process.env,
             NODE_ENV: process.env.NODE_ENV || 'production',
             WORKER_ID: workerId.toString(),
+            PORT: port.toString(),
             CLUSTER_WORKER: 'true',
-            FORCE_COLOR: this.options.color ? '1' : '0'
+            FORCE_COLOR: this.options.color ? '1' : '0',
+            NODE_OPTIONS: '--no-deprecation'
         };
-        if (this.options.port) {
-            env.PORT = this.options.port.toString();
-        }
         const workerProcess = (0, child_process_1.fork)(this.options.file, [], {
             cwd: this.options.workingDir,
             env,
             execArgv: nodeArgs,
-            silent: false
+            silent: true
         });
         const workerInfo = {
             process: workerProcess,
             pid: workerProcess.pid,
             restarts: 0,
-            startTime: new Date()
+            startTime: new Date(),
+            id: workerId,
+            port: port
         };
         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);
+            if (message && !message.includes('[dotenv@') && !message.includes('injecting env')) {
+                const prefix = this.options.verbose ?
+                    chalk_1.default.dim(`[Worker ${workerId}] `) : '';
+                console.log(prefix + message);
             }
         });
         (_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));
+            if (message && !message.includes('[dotenv@') && !message.includes('injecting env')) {
+                const prefix = this.options.verbose ?
+                    chalk_1.default.dim(`[Worker ${workerId}] `) : '';
+                console.error(prefix + chalk_1.default.red(message));
             }
         });
         workerProcess.on('error', (error) => {
@@ -129,12 +209,35 @@ class StartManager {
         });
         workerProcess.on('exit', (code, signal) => {
             this.workers.delete(workerId);
-            if (!this.isShuttingDown) {
+            if (!this.isShuttingDown && code !== 0 && signal !== 'SIGTERM') {
+                this.log(`Worker ${workerId} crashed (code: ${code}, signal: ${signal})`, 'error');
+                this.restartWorker(workerId);
+            }
+        });
+        // Wait for worker to be ready
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                resolve(); // Don't reject, assume it's ready
+            }, 5000);
+            workerProcess.on('message', (message) => {
+                if (message && message.type === 'ready') {
+                    clearTimeout(timeout);
+                    resolve();
+                }
+            });
+            workerProcess.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+            workerProcess.on('exit', (code) => {
+                clearTimeout(timeout);
                 if (code !== 0) {
-                    this.log(`Worker ${workerId} crashed (code: ${code})`, 'error');
-                    this.restartWorker(workerId);
+                    reject(new Error(`Worker ${workerId} exited with code ${code}`));
                 }
-            }
+                else {
+                    resolve();
+                }
+            });
         });
         if (this.options.verbose) {
             this.log(`Worker ${workerId} started (PID: ${workerProcess.pid})`);
@@ -147,7 +250,7 @@ class StartManager {
             workerInfo.restarts++;
             this.totalRestarts++;
             if (workerInfo.restarts >= this.options.maxCrashes) {
-                this.log(`Worker ${workerId} reached max crashes, not restarting`, 'error');
+                this.log(`Worker ${workerId} reached max crashes (${this.options.maxCrashes}), not restarting`, 'error');
                 return;
             }
             if (this.options.verbose) {
@@ -174,30 +277,64 @@ class StartManager {
                 clearTimeout(timer);
                 resolve();
             });
+            if (process.killed) {
+                clearTimeout(timer);
+                resolve();
+            }
         });
     }
     async startCluster() {
+        if (this.options.workers === 1) {
+            // Single process mode
+            await this.startSingleProcess();
+            return;
+        }
+        // Multi-worker mode
+        const startPromises = [];
         for (let i = 0; i < this.options.workers; i++) {
-            await this.startWorker(i + 1);
+            startPromises.push(this.startWorker(i + 1));
+        }
+        try {
+            await Promise.all(startPromises);
+        }
+        catch (error) {
+            this.log(`Failed to start some workers: ${error.message}`, 'error');
+            // Continue with successfully started workers
         }
     }
     setupHealthCheck() {
         if (!this.options.healthCheck)
             return;
         this.healthServer = http_1.default.createServer((req, res) => {
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            if (req.method === 'OPTIONS') {
+                res.writeHead(200);
+                res.end();
+                return;
+            }
             if (req.url === '/health') {
                 const stats = {
                     status: 'ok',
                     uptime: Date.now() - this.startTime.getTime(),
                     workers: this.workers.size,
+                    activeWorkers: Array.from(this.workers.values()).map(w => ({
+                        id: w.id,
+                        pid: w.pid,
+                        restarts: w.restarts,
+                        uptime: Date.now() - w.startTime.getTime()
+                    })),
                     totalRestarts: this.totalRestarts,
-                    memory: process.memoryUsage()
+                    memory: process.memoryUsage(),
+                    cpu: os_1.default.loadavg(),
+                    port: this.options.port || 8000
                 };
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify(stats));
+                res.end(JSON.stringify(stats, null, 2));
             }
             else {
-                res.writeHead(404);
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
                 res.end('Not Found');
             }
         });
@@ -216,9 +353,13 @@ class StartManager {
             `${this.options.workingDir}/**/*.env*`
         ];
         this.watcher = (0, chokidar_1.watch)(watchPatterns, {
-            ignored: ['**/node_modules/**', '**/.git/**', '**/logs/**'],
+            ignored: ['**/node_modules/**', '**/.git/**', '**/logs/**', '**/tmp/**'],
             ignoreInitial: true,
-            atomic: 300
+            atomic: 300,
+            awaitWriteFinish: {
+                stabilityThreshold: 2000,
+                pollInterval: 100
+            }
         });
         this.watcher.on('change', (filePath) => {
             if (this.options.verbose) {
@@ -226,6 +367,9 @@ class StartManager {
             }
             this.debouncedRestart();
         });
+        this.watcher.on('error', (error) => {
+            this.log(`Watcher error: ${error.message}`, 'error');
+        });
         if (this.options.verbose) {
             this.log('File watching enabled');
         }
@@ -234,53 +378,56 @@ class StartManager {
         if (this.isShuttingDown)
             return;
         this.log('Restarting due to file changes...');
-        for (const [workerId, workerInfo] of this.workers.entries()) {
+        if (this.options.workers === 1 && this.masterProcess) {
+            // Single process restart
             try {
-                workerInfo.process.kill('SIGTERM');
-                await this.waitForProcessExit(workerInfo.process, 5000);
+                this.masterProcess.kill('SIGTERM');
+                await this.waitForProcessExit(this.masterProcess, 5000);
             }
             catch (error) {
-                workerInfo.process.kill('SIGKILL');
+                this.masterProcess.kill('SIGKILL');
             }
             setTimeout(() => {
-                this.startWorker(workerId);
+                this.startSingleProcess();
             }, 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);
+        else {
+            // Multi-worker restart
+            const restartPromises = [];
+            for (const [workerId, workerInfo] of this.workers.entries()) {
+                restartPromises.push((async () => {
+                    try {
+                        workerInfo.process.kill('SIGTERM');
+                        await this.waitForProcessExit(workerInfo.process, 5000);
                     }
-                }
-                catch (error) {
-                    // Ignore monitoring errors
-                }
-            });
-        }, 30000); // Check every 30 seconds
+                    catch (error) {
+                        workerInfo.process.kill('SIGKILL');
+                    }
+                })());
+            }
+            await Promise.allSettled(restartPromises);
+            setTimeout(() => {
+                this.startCluster();
+            }, this.options.restartDelay);
+        }
     }
     async start() {
         try {
+            // Load environment variables
             this.loadEnvFile();
+            // Set up monitoring and health checks
             this.setupHealthCheck();
             this.setupWatcher();
-            this.setupMemoryMonitoring();
+            // Start the application
             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');
+            const port = this.options.port || 8000;
+            const workerInfo = this.options.workers === 1 ?
+                '' : ` (${this.workers.size} workers)`;
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Server ready on port ${port}${workerInfo}`, 'info');
         }
         catch (error) {
+            this.log(`Failed to start server: ${error.message}`, 'error');
             throw error;
         }
     }
@@ -288,12 +435,24 @@ class StartManager {
         if (this.isShuttingDown)
             return;
         this.isShuttingDown = true;
+        this.log('Shutting down gracefully...');
         if (this.watcher) {
             await this.watcher.close();
         }
         if (this.healthServer) {
             this.healthServer.close();
         }
+        // Stop single process
+        if (this.masterProcess) {
+            try {
+                this.masterProcess.kill('SIGTERM');
+                await this.waitForProcessExit(this.masterProcess, this.options.gracefulTimeout);
+            }
+            catch (error) {
+                this.masterProcess.kill('SIGKILL');
+            }
+        }
+        // Stop workers
         const shutdownPromises = [];
         for (const [workerId, workerInfo] of this.workers.entries()) {
             shutdownPromises.push((async () => {
@@ -308,6 +467,7 @@ class StartManager {
         }
         await Promise.allSettled(shutdownPromises);
         this.workers.clear();
+        this.log('Server stopped');
     }
 }
 exports.StartManager = StartManager;

package/package.json

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