neex 0.6.47 → 0.6.50

package/dist/src/start-manager.js

@@ -4,118 +4,407 @@ 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 server manager for built TypeScript projects
 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 promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = require("fs");
+const perf_hooks_1 = require("perf_hooks");
 class StartManager {
     constructor(options) {
-        this.process = null;
-        this.isStopping = false;
+        this.serverProcess = null;
+        this.watcher = null;
+        this.isStarting = false;
+        this.restartCount = 0;
+        this.startTime = 0;
+        this.isShuttingDown = false;
+        this.restartTimer = null;
         this.options = options;
     }
-    async startProcess() {
-        var _a, _b;
-        if (this.process) {
-            return;
+    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);
         }
-        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');
+        // Try with .js extension
+        if (!entryPath.endsWith('.js')) {
+            const jsPath = entryPath + '.js';
+            if ((0, fs_1.existsSync)(jsPath)) {
+                return path_1.default.resolve(jsPath);
+            }
         }
-        (_a = this.process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-            if (!this.options.quiet) {
-                process.stdout.write(data);
+        // Try in dist directory
+        const distPath = path_1.default.join('dist', entryPath);
+        if ((0, fs_1.existsSync)(distPath)) {
+            return path_1.default.resolve(distPath);
+        }
+        // Try in dist with .js extension
+        if (!entryPath.endsWith('.js')) {
+            const distJsPath = path_1.default.join('dist', entryPath + '.js');
+            if ((0, fs_1.existsSync)(distJsPath)) {
+                return path_1.default.resolve(distJsPath);
             }
-        });
-        (_b = this.process.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+        }
+        // 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');
+                }
+                return path_1.default.resolve(entry);
+            }
+        }
+        throw new Error(`Entry file not found: ${entryPath}`);
+    }
+    async loadPackageJson() {
+        try {
+            const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+            if ((0, fs_1.existsSync)(packageJsonPath)) {
+                const content = await promises_1.default.readFile(packageJsonPath, 'utf8');
+                return JSON.parse(content);
+            }
+        }
+        catch (error) {
+            // Ignore package.json errors
+        }
+        return null;
+    }
+    getNodeArgs() {
+        const args = [];
+        // Add custom node arguments
+        if (this.options.nodeArgs.length > 0) {
+            args.push(...this.options.nodeArgs);
+        }
+        // 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}`);
+        }
+        // Production optimizations
+        if (this.options.env === 'production') {
+            args.push('--optimize-for-size');
+        }
+        return args;
+    }
+    getEnvironment() {
+        const env = {
+            ...process.env,
+            NODE_ENV: this.options.env,
+            PORT: this.options.port.toString(),
+            HOST: this.options.host,
+            LOG_LEVEL: this.options.logLevel
+        };
+        // Add color support
+        if (this.options.color) {
+            env.FORCE_COLOR = '1';
+        }
+        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');
+                }
+            }
+            catch (error) {
+                logger_manager_js_1.loggerManager.printLine(`Failed to write PID file: ${error.message}`, 'warn');
+            }
+        }
+    }
+    async removePidFile() {
+        if (this.options.pid && (0, fs_1.existsSync)(this.options.pid)) {
+            try {
+                await promises_1.default.unlink(this.options.pid);
+                if (this.options.verbose) {
+                    logger_manager_js_1.loggerManager.printLine(`PID file removed: ${this.options.pid}`, 'info');
+                }
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    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) {
-                process.stderr.write(data);
+                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');
+                    }
+                }
             }
-        });
-        this.process.on('error', (error) => {
-            logger_manager_js_1.loggerManager.printLine(`Application 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();
+            const args = [...nodeArgs, entryPath];
+            this.serverProcess = (0, child_process_1.spawn)('node', args, {
+                stdio: this.options.verbose ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'ignore', 'pipe'],
+                env,
+                detached: false,
+                cwd: process.cwd()
+            });
+            if (this.serverProcess.pid) {
+                await this.writePidFile(this.serverProcess.pid);
+            }
+            // 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');
+                    }
+                });
+            }
+            // 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');
+                    }
+                });
+            }
+            // Handle process events
+            this.serverProcess.on('error', (error) => {
+                this.isStarting = false;
+                if (!this.isShuttingDown) {
+                    logger_manager_js_1.loggerManager.printLine(`Server process error: ${error.message}`, 'error');
+                    this.handleServerExit(1);
+                }
+            });
+            this.serverProcess.on('exit', (code, signal) => {
+                this.isStarting = false;
+                if (!this.isShuttingDown) {
+                    this.handleServerExit(code || 0, signal || undefined);
                 }
+            });
+            // Wait for server to start
+            await this.waitForServerStart();
+            this.isStarting = false;
+            const duration = Math.round(perf_hooks_1.performance.now() - this.startTime);
+            if (!this.options.quiet) {
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Server started successfully in ${duration}ms`, 'info');
+                logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Running on ${chalk_1.default.cyan(`http://${this.options.host}:${this.options.port}`)}`, 'info');
+            }
+        }
+        catch (error) {
+            this.isStarting = false;
+            throw error;
+        }
+    }
+    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();
+                    }
+                };
+                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);
+            }
+            else {
+                clearTimeout(timeout);
+                reject(new Error('Server process not created'));
             }
         });
     }
-    async start() {
-        if (!fs_1.default.existsSync(this.options.entry)) {
-            throw new Error(`Entry file not found: ${this.options.entry}`);
+    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();
         }
-        await this.startProcess();
+        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.green(figures_1.default.tick)} Application is running.`, 'info');
+            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);
     }
-    async stop() {
-        this.isStopping = true;
-        const proc = this.process;
-        if (!proc) {
+    setupWatcher() {
+        if (!this.options.watch)
+            return;
+        const watchPatterns = [
+            'dist/**/*.js',
+            'package.json',
+            'dist/package.json'
+        ];
+        this.watcher = (0, chokidar_1.watch)(watchPatterns, {
+            ignoreInitial: true,
+            followSymlinks: false,
+            usePolling: false,
+            atomic: 500,
+            ignored: [
+                '**/node_modules/**',
+                '**/.git/**',
+                '**/*.log',
+                '**/*.map'
+            ]
+        });
+        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.restart();
+        });
+        this.watcher.on('error', (error) => {
+            logger_manager_js_1.loggerManager.printLine(`Watcher error: ${error.message}`, 'error');
+        });
+        if (this.options.verbose) {
+            logger_manager_js_1.loggerManager.printLine(`Watching: ${watchPatterns.join(', ')}`, 'info');
+        }
+    }
+    async restart() {
+        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.process = null;
+        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) => {
-            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');
+            if (!this.serverProcess) {
                 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');
+                return;
+            }
+            const proc = this.serverProcess;
+            this.serverProcess = null;
+            if (this.restartTimer) {
+                clearTimeout(this.restartTimer);
+                this.restartTimer = null;
+            }
+            const cleanup = () => {
+                this.removePidFile();
                 resolve();
-            });
+            };
+            proc.on('exit', cleanup);
+            proc.on('error', cleanup);
             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
+                    // Graceful shutdown
+                    proc.kill('SIGTERM');
+                    // Force kill after timeout
                     setTimeout(() => {
-                        if (!proc.killed) {
+                        if (proc.pid && !proc.killed) {
                             try {
-                                process.kill(-pid, 'SIGKILL');
+                                proc.kill('SIGKILL');
                             }
                             catch (e) {
-                                // Ignore errors if the process is already gone
+                                // Ignore
                             }
                         }
-                    }, 5000).unref(); // .unref() allows the main process to exit if this is the only thing running
+                    }, this.options.gracefulTimeout);
                 }
             }
-            catch (e) {
-                // This can happen if the process is already dead
-                resolve();
+            catch (error) {
+                cleanup();
             }
         });
     }
+    async start() {
+        try {
+            await this.startServer();
+            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');
+            }
+        }
+        catch (error) {
+            logger_manager_js_1.loggerManager.printLine(`Failed to start server: ${error.message}`, 'error');
+            process.exit(1);
+        }
+    }
+    async stop() {
+        this.isShuttingDown = true;
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Stopping server...`, 'info');
+        }
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+        await this.stopServer();
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Server stopped successfully`, 'info');
+        }
+    }
 }
 exports.StartManager = StartManager;

package/package.json

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