npm - neex - Versions diffs - 0.6.50 → 0.6.51 - Mend

neex 0.6.50 → 0.6.51

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/src/commands/start-commands.js +142 -153
package/dist/src/start-manager.js +350 -304
package/package.json +1 -1

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

@@ -8,63 +8,86 @@ 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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 function addStartCommands(program) {
     let startManager = null;
-    // Main start command
+    // Start command for production execution
     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')
+        .command('start [file]')
+        .description('Start production application (default: dist/index.js)')
+        .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('--workers <count>', 'Number of worker processes (default: CPU count)', os_1.default.cpus().length.toString())
-        .option('-m, --memory <mb>', 'Memory limit in MB', '512')
-        .option('-t, --timeout <ms>', 'Startup timeout in milliseconds', '30000')
-        .option('--graceful-timeout <ms>', 'Graceful shutdown timeout in milliseconds', '5000')
-        .option('-v, --verbose', 'Verbose output')
-        .option('-q, --quiet', 'Quiet output')
+        .option('-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('--log-level <level>', 'Log level (error, warn, info, debug)', 'info')
-        .option('--node-args <args>', 'Additional Node.js arguments (comma-separated)')
+        .option('-q, --quiet', 'Quiet mode')
+        .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('--health-port <port>', 'Health check port', parseInt, 3001)
+        .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')
+        .option('--node-args <args>', 'Additional Node.js arguments')
+        .action(async (file, options) => {
         try {
-            const entryFile = entry || 'dist/index.js';
+            const targetFile = file || 'dist/index.js';
+            const resolvedFile = path_1.default.resolve(options.dir, targetFile);
+            // Check if file exists
+            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'));
+                    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 from package.json: ${mainFile}`, 'info');
+                        }
+                    }
+                    else {
+                        throw new Error(`Neither ${targetFile} nor ${mainFile} found. Please build your project first.`);
+                    }
+                }
+                else {
+                    throw new Error(`File not found: ${resolvedFile}. Please build your project first.`);
+                }
+            }
             if (!options.quiet) {
-                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting production server...`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting production server: ${chalk_1.default.cyan(targetFile)}`, '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,
+                file: resolvedFile,
+                workingDir: options.dir,
+                envFile: options.env,
+                port: options.port,
+                workers: options.workers,
                 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,
+                memoryLimit: options.memory,
                 logLevel: options.logLevel,
-                nodeArgs,
+                logFile: options.logFile,
+                color: options.color,
+                quiet: options.quiet,
+                verbose: options.verbose,
+                watch: options.watch,
+                maxMemory: options.maxMemory,
+                maxCrashes: options.maxCrashes,
+                restartDelay: options.restartDelay,
+                healthCheck: options.healthCheck,
+                healthPort: options.healthPort,
+                gracefulTimeout: options.gracefulTimeout,
                 inspect: options.inspect,
-                inspectPort: parseInt(options.inspectPort),
-                pid: options.pid,
-                restart: options.restart,
-                restartDelay: parseInt(options.restartDelay),
-                maxRestarts: parseInt(options.maxRestarts)
+                inspectBrk: options.inspectBrk,
+                nodeArgs: options.nodeArgs
             });
             await startManager.start();
         }
@@ -78,135 +101,109 @@ function addStartCommands(program) {
             process.exit(1);
         }
     });
-    // Quick start command for development
+    // Quick start command
     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) => {
+        .command('run [file]')
+        .description('Quick start without options (alias for start)')
+        .action(async (file) => {
         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');
+            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({
-                entry: entryFile,
-                port: parseInt(options.port),
-                host: '127.0.0.1',
-                env: 'development',
-                watch: true,
-                cluster: false,
+                file: path_1.default.resolve(targetFile),
+                workingDir: process.cwd(),
+                envFile: '.env',
+                port: undefined,
                 workers: 1,
-                memory: 256,
-                timeout: 15000,
-                gracefulTimeout: 3000,
-                verbose: options.verbose,
-                quiet: false,
-                color: true,
+                cluster: false,
+                memoryLimit: undefined,
                 logLevel: 'info',
-                nodeArgs: [],
+                logFile: undefined,
+                color: true,
+                quiet: false,
+                verbose: false,
+                watch: false,
+                maxMemory: undefined,
+                maxCrashes: 5,
+                restartDelay: 1000,
+                healthCheck: false,
+                healthPort: 3001,
+                gracefulTimeout: 30000,
                 inspect: false,
-                inspectPort: 9229,
-                pid: '',
-                restart: true,
-                restartDelay: 500,
-                maxRestarts: 50
+                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)} Serve failed: ${error.message}`, 'error');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Run 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');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown run error occurred`, 'error');
             }
             process.exit(1);
         }
     });
-    // Production deployment command
+    // Production command with clustering
     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) => {
+        .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 entryFile = entry || 'dist/index.js';
-            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Deploying to production...`, 'info');
+            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({
-                entry: entryFile,
-                port: parseInt(options.port),
-                host: '0.0.0.0',
-                env: 'production',
-                watch: false,
+                file: resolvedFile,
+                workingDir: process.cwd(),
+                envFile: options.env,
+                port: options.port,
+                workers,
                 cluster: true,
-                workers: parseInt(options.workers),
-                memory: parseInt(options.memory),
-                timeout: 30000,
-                gracefulTimeout: 10000,
-                verbose: options.verbose,
-                quiet: false,
+                memoryLimit: undefined,
+                logLevel: 'info',
+                logFile: options.logFile,
                 color: false,
-                logLevel: 'warn',
-                nodeArgs: ['--optimize-for-size'],
-                inspect: false,
-                inspectPort: 9229,
-                pid: options.pid,
-                restart: true,
+                quiet: options.quiet,
+                verbose: false,
+                watch: false,
+                maxMemory: '1G',
+                maxCrashes: 3,
                 restartDelay: 2000,
-                maxRestarts: 5
+                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)} Deploy failed: ${error.message}`, '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 deploy error occurred`, 'error');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} An unknown production start error occurred`, '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 +219,7 @@ 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');
+            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(() => {
@@ -236,19 +233,11 @@ 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')); // PM2 restart
+    process.on('exit', () => {
+        if (startManager) {
+            cleanupStart();
+        }
     });
     return { cleanupStart };
 }

package/dist/src/start-manager.js CHANGED Viewed

@@ -4,407 +4,453 @@ 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 - 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 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.masterProcess = null;
         this.watcher = null;
-        this.isStarting = false;
-        this.restartCount = 0;
-        this.startTime = 0;
+        this.healthServer = null;
         this.isShuttingDown = false;
-        this.restartTimer = null;
+        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 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);
+    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');
             }
         }
-        // Try in dist directory
-        const distPath = path_1.default.join('dist', entryPath);
-        if ((0, fs_1.existsSync)(distPath)) {
-            return path_1.default.resolve(distPath);
+    }
+    log(message, level = 'info') {
+        const timestamp = new Date().toISOString();
+        const logMessage = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
+        if (this.logStream) {
+            this.logStream.write(logMessage + '\n');
         }
-        // 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);
-            }
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(message, level);
         }
-        // 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');
+    }
+    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}`);
                 }
-                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) {
+                this.log(`Failed to load environment file: ${error.message}`, 'warn');
             }
         }
-        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) {
+            args.push(`--max-old-space-size=${this.parseMemoryLimit(this.options.memoryLimit) / (1024 * 1024)}`);
         }
-        // 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: 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) {
+                const message = data.toString().trim();
+                if (message) {
+                    console.log(chalk_1.default.dim(`[Worker ${workerId}]`) + ' ' + 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) => {
+            if (!this.options.quiet) {
+                const message = data.toString().trim();
+                if (message) {
+                    console.error(chalk_1.default.dim(`[Worker ${workerId}]`) + ' ' + chalk_1.default.red(message));
+                }
             }
-        }
+        });
+        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} 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 removePidFile() {
-        if (this.options.pid && (0, fs_1.existsSync)(this.options.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 (${this.options.maxCrashes}), not restarting`, 'error');
+                return;
+            }
+            this.log(`Restarting worker ${workerId} (restart #${workerInfo.restarts})`);
+            // Graceful shutdown
             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');
-                }
+                workerInfo.process.kill('SIGTERM');
+                await this.waitForProcessExit(workerInfo.process, 5000);
             }
             catch (error) {
-                // Ignore cleanup errors
+                workerInfo.process.kill('SIGKILL');
             }
+            // Start new worker
+            setTimeout(() => {
+                this.startWorker(workerId);
+            }, this.options.restartDelay);
         }
     }
-    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()
+    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();
             });
-            if (this.serverProcess.pid) {
-                await this.writePidFile(this.serverProcess.pid);
-            }
-            // 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');
+        });
+    }
+    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);
                     }
-                });
-            }
-            // 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');
+                    else {
+                        this.log(`Reached max crashes (${this.options.maxCrashes}), giving up`, 'error');
+                        process.exit(1);
                     }
-                });
-            }
-            // 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);
+                else {
+                    this.log('Process exited gracefully');
                 }
-            });
-            // 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) {
-            this.isStarting = false;
-            throw error;
+        });
+        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 waitForServerStart() {
-        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();
-                    }
+    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()
                 };
-                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, null, 2));
             }
             else {
-                clearTimeout(timeout);
-                reject(new Error('Server process not created'));
+                res.writeHead(404);
+                res.end('Not Found');
             }
         });
-    }
-    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);
+        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 = [
-            '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, {
-            ignoreInitial: true,
-            followSymlinks: false,
-            usePolling: false,
-            atomic: 500,
             ignored: [
                 '**/node_modules/**',
                 '**/.git/**',
-                '**/*.log',
-                '**/*.map'
-            ]
+                '**/logs/**',
+                '**/*.log'
+            ],
+            ignoreInitial: true,
+            followSymlinks: false,
+            usePolling: false,
+            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.debouncedRestart();
         });
         this.watcher.on('error', (error) => {
-            logger_manager_js_1.loggerManager.printLine(`Watcher error: ${error.message}`, 'error');
+            this.log(`Watcher error: ${error.message}`, 'error');
         });
-        if (this.options.verbose) {
-            logger_manager_js_1.loggerManager.printLine(`Watching: ${watchPatterns.join(', ')}`, 'info');
-        }
+        this.log('File watcher 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');
+        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);
+            }
         }
-        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;
+        else if (this.masterProcess) {
+            // Restart single process
+            try {
+                this.masterProcess.kill('SIGTERM');
+                await this.waitForProcessExit(this.masterProcess, 5000);
             }
-            const proc = this.serverProcess;
-            this.serverProcess = null;
-            if (this.restartTimer) {
-                clearTimeout(this.restartTimer);
-                this.restartTimer = null;
+            catch (error) {
+                this.masterProcess.kill('SIGKILL');
             }
-            const cleanup = () => {
-                this.removePidFile();
-                resolve();
-            };
-            proc.on('exit', cleanup);
-            proc.on('error', cleanup);
-            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
+            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);
                             }
                         }
-                    }, this.options.gracefulTimeout);
-                }
-            }
-            catch (error) {
-                cleanup();
+                    }
+                    catch (error) {
+                        // Ignore monitoring errors
+                    }
+                });
             }
-        });
+        }, 10000); // Check every 10 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.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) {
-            logger_manager_js_1.loggerManager.printLine(`Failed to start server: ${error.message}`, 'error');
-            process.exit(1);
+            this.log(`Failed to start application: ${error.message}`, 'error');
+            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');
-        }
+        this.log('Stopping application...');
+        // Stop watcher
         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');
+        // 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 CHANGED Viewed

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