neex 0.6.47 → 0.6.51

package/dist/src/start-manager.js

@@ -4,118 +4,453 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartManager = void 0;
-// src/start-manager.ts - Production application runner
+// src/start-manager.ts - Production start manager with clustering and monitoring
 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 fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const lodash_1 = require("lodash");
 class StartManager {
     constructor(options) {
-        this.process = null;
-        this.isStopping = false;
+        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();
     }
-    async startProcess() {
-        var _a, _b;
-        if (this.process) {
-            return;
+    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');
         }
-        const nodeArgs = this.options.nodeArgs || [];
-        const args = [...nodeArgs, this.options.entry];
-        if (this.options.verbose) {
-            logger_manager_js_1.loggerManager.printLine(`Executing: node ${args.join(' ')}`, 'info');
-        }
-        this.process = (0, child_process_1.spawn)('node', args, {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            shell: false,
-            env: {
-                ...process.env,
-                NODE_ENV: 'production',
-                FORCE_COLOR: this.options.color ? '1' : '0'
-            },
-            detached: true
-        });
-        const appName = this.options.name || path_1.default.basename(this.options.entry);
         if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.play)} Starting ${chalk_1.default.cyan(appName)} in production mode...`, '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();
+                            // 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');
+            }
+        }
+    }
+    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 = [];
+        if (this.options.memoryLimit) {
+            args.push(`--max-old-space-size=${this.parseMemoryLimit(this.options.memoryLimit) / (1024 * 1024)}`);
+        }
+        if (this.options.inspect) {
+            args.push('--inspect');
+        }
+        if (this.options.inspectBrk) {
+            args.push('--inspect-brk');
         }
-        (_a = this.process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+        if (this.options.nodeArgs) {
+            args.push(...this.options.nodeArgs.split(' '));
+        }
+        return args;
+    }
+    async startWorker(workerId) {
+        var _a, _b;
+        const nodeArgs = this.getNodeArgs();
+        const env = {
+            ...process.env,
+            NODE_ENV: process.env.NODE_ENV || 'production',
+            WORKER_ID: workerId.toString(),
+            CLUSTER_WORKER: 'true',
+            FORCE_COLOR: this.options.color ? '1' : '0'
+        };
+        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: true
+        });
+        const workerInfo = {
+            process: workerProcess,
+            pid: workerProcess.pid,
+            restarts: 0,
+            startTime: new Date(),
+            memoryUsage: 0,
+            cpuUsage: 0
+        };
+        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) {
-                process.stdout.write(data);
+                const message = data.toString().trim();
+                if (message) {
+                    console.log(chalk_1.default.dim(`[Worker ${workerId}]`) + ' ' + message);
+                }
             }
         });
-        (_b = this.process.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+        (_b = workerProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
             if (!this.options.quiet) {
-                process.stderr.write(data);
+                const message = data.toString().trim();
+                if (message) {
+                    console.error(chalk_1.default.dim(`[Worker ${workerId}]`) + ' ' + chalk_1.default.red(message));
+                }
             }
         });
-        this.process.on('error', (error) => {
-            logger_manager_js_1.loggerManager.printLine(`Application error: ${error.message}`, 'error');
+        workerProcess.on('error', (error) => {
+            this.log(`Worker ${workerId} error: ${error.message}`, 'error');
         });
-        this.process.on('exit', (code) => {
-            this.process = null;
-            if (!this.isStopping) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Application ${appName} exited with code ${code}`, 'error');
-                if (this.options.watch) {
-                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.arrowRight)} Restarting application...`, 'info');
-                    this.startProcess();
+        workerProcess.on('exit', (code, signal) => {
+            this.workers.delete(workerId);
+            if (!this.isShuttingDown) {
+                if (code !== 0) {
+                    this.log(`Worker ${workerId} exited with 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})`);
+        return workerInfo;
     }
-    async start() {
-        if (!fs_1.default.existsSync(this.options.entry)) {
-            throw new Error(`Entry file not found: ${this.options.entry}`);
+    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 (${this.options.maxCrashes}), not restarting`, 'error');
+                return;
+            }
+            this.log(`Restarting worker ${workerId} (restart #${workerInfo.restarts})`);
+            // Graceful shutdown
+            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);
         }
-        await this.startProcess();
-        if (!this.options.quiet) {
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Application is running.`, 'info');
+    }
+    async waitForProcessExit(process, timeout) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error('Process exit timeout'));
+            }, timeout);
+            process.on('exit', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+    }
+    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);
         }
     }
-    async stop() {
-        this.isStopping = true;
-        const proc = this.process;
-        if (!proc) {
+    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,
+                    memoryUsage: process.memoryUsage(),
+                    cpuUsage: process.cpuUsage()
+                };
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(stats, null, 2));
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not Found');
+            }
+        });
+        this.healthServer.listen(this.options.healthPort, () => {
+            this.log(`Health check server listening on port ${this.options.healthPort}`);
+        });
+    }
+    setupWatcher() {
+        if (!this.options.watch)
+            return;
+        const watchPatterns = [
+            `${this.options.workingDir}/**/*.js`,
+            `${this.options.workingDir}/**/*.json`,
+            `${this.options.workingDir}/**/*.env*`
+        ];
+        this.watcher = (0, chokidar_1.watch)(watchPatterns, {
+            ignored: [
+                '**/node_modules/**',
+                '**/.git/**',
+                '**/logs/**',
+                '**/*.log'
+            ],
+            ignoreInitial: true,
+            followSymlinks: false,
+            usePolling: false,
+            atomic: 300
+        });
+        this.watcher.on('change', (filePath) => {
+            if (this.options.verbose) {
+                this.log(`File changed: ${path_1.default.relative(this.options.workingDir, filePath)}`);
+            }
+            this.debouncedRestart();
+        });
+        this.watcher.on('error', (error) => {
+            this.log(`Watcher error: ${error.message}`, 'error');
+        });
+        this.log('File watcher 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);
+            }
         }
-        this.process = null;
-        return new Promise((resolve) => {
-            const appName = this.options.name || path_1.default.basename(this.options.entry);
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Stopping application ${appName}...`, 'info');
-            proc.on('exit', () => {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.square)} Application stopped.`, 'info');
-                resolve();
-            });
-            proc.on('error', () => {
-                // Handle errors during shutdown, e.g., if the process is already gone
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.square)} Application stopped.`, 'info');
-                resolve();
-            });
+        else if (this.masterProcess) {
+            // Restart single process
             try {
-                if (proc.pid) {
-                    const pid = proc.pid;
-                    // Kill the entire process group
-                    process.kill(-pid, 'SIGTERM');
-                    // Set a timeout to force kill if it doesn't terminate gracefully
-                    setTimeout(() => {
-                        if (!proc.killed) {
-                            try {
-                                process.kill(-pid, 'SIGKILL');
-                            }
-                            catch (e) {
-                                // Ignore errors if the process is already gone
+                this.masterProcess.kill('SIGTERM');
+                await this.waitForProcessExit(this.masterProcess, 5000);
+            }
+            catch (error) {
+                this.masterProcess.kill('SIGKILL');
+            }
+            setTimeout(() => {
+                this.startSingleProcess();
+            }, this.options.restartDelay);
+        }
+    }
+    setupMonitoring() {
+        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);
                             }
                         }
-                    }, 5000).unref(); // .unref() allows the main process to exit if this is the only thing running
-                }
+                    }
+                    catch (error) {
+                        // Ignore monitoring errors
+                    }
+                });
             }
-            catch (e) {
-                // This can happen if the process is already dead
-                resolve();
+        }, 10000); // Check every 10 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
+                })}`);
+            }
+        }
+        catch (error) {
+            this.log(`Failed to start application: ${error.message}`, 'error');
+            throw error;
+        }
+    }
+    async stop() {
+        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 () => {
+                try {
+                    workerInfo.process.kill('SIGTERM');
+                    await this.waitForProcessExit(workerInfo.process, this.options.gracefulTimeout);
+                }
+                catch (error) {
+                    workerInfo.process.kill('SIGKILL');
+                }
+            })());
+        }
+        // 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.47",
+  "version": "0.6.51",
   "description": "The Modern Build System for Polyrepo-in-Monorepo Architecture",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",