neex 0.6.17 → 0.6.20

package/dist/src/start-manager.js

@@ -0,0 +1,384 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartManager = void 0;
+// src/start-manager.ts - Production application start manager with monitoring
+const watcher_1 = require("./watcher");
+const runner_1 = require("./runner");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const logger_1 = __importDefault(require("./logger"));
+const os = __importStar(require("os"));
+class StartManager {
+    constructor(options) {
+        this.isRunning = false;
+        this.restartCount = 0;
+        this.crashCount = 0;
+        this.startTime = new Date();
+        this.processStats = {
+            memoryUsage: 0,
+            cpuUsage: 0,
+            uptime: 0
+        };
+        const defaultOptions = {
+            parallel: false,
+            printOutput: true,
+            color: true,
+            showTiming: true,
+            prefix: true,
+            stopOnError: false,
+            minimalOutput: false,
+            groupOutput: false,
+            isServerMode: true,
+            watch: false,
+            watchPaths: [],
+            ignore: [
+                'node_modules/**',
+                '.git/**',
+                '*.log',
+                'src/**',
+                'test/**',
+                'tests/**',
+                'coverage/**',
+                '.nyc_output/**',
+                '*.tmp',
+                '*.temp'
+            ],
+            ext: ['js', 'mjs', 'json'],
+            delay: 1000,
+            verbose: false,
+            showInfo: false,
+            runnerName: 'neex start',
+            environment: 'production',
+            maxRestarts: 10,
+            restartDelay: 3000,
+            signal: 'SIGTERM',
+            cluster: false,
+            clusterInstances: os.cpus().length
+        };
+        this.options = {
+            ...defaultOptions,
+            ...options
+        };
+    }
+    setupFileWatcher() {
+        var _a;
+        if (!this.options.watch || !((_a = this.options.watchPaths) === null || _a === void 0 ? void 0 : _a.length)) {
+            return;
+        }
+        const watchOptions = {
+            watch: this.options.watchPaths,
+            ignore: this.options.ignore,
+            ext: this.options.ext,
+            delay: this.options.delay,
+            verbose: this.options.verbose && this.options.showInfo
+        };
+        this.fileWatcher = new watcher_1.FileWatcher(watchOptions);
+        this.fileWatcher.on('change', (event) => {
+            if (this.options.watch && this.isRunning) {
+                this.handleFileChange(event);
+            }
+        });
+    }
+    async handleFileChange(event) {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} File changed: ${chalk_1.default.yellow(event.relativePath)}`, 'info');
+        }
+        await this.gracefulRestart();
+    }
+    generateClusterCommand() {
+        if (!this.options.cluster) {
+            return this.options.command;
+        }
+        const instances = this.options.clusterInstances || os.cpus().length;
+        const baseCommand = this.options.command;
+        // For cluster mode, we'll use a simple approach with PM2-like clustering
+        // This is a simplified implementation - in real production, you'd use PM2 or similar
+        return `${baseCommand} --cluster=${instances}`;
+    }
+    async startApplication() {
+        const command = this.generateClusterCommand();
+        // Set environment variables
+        const env = {
+            ...process.env,
+            NODE_ENV: this.options.environment,
+            NEEX_START_MODE: 'production',
+            NEEX_PROCESS_NAME: this.options.processName
+        };
+        // Create a modified options object for the runner
+        const runnerOptions = {
+            ...this.options,
+            env,
+            customPrefix: () => this.options.processName,
+            // Override some options for production
+            stopOnError: false,
+            restartOnFailure: true,
+            maxRestarts: this.options.maxRestarts,
+            restartDelay: this.options.restartDelay
+        };
+        this.runner = new runner_1.Runner(runnerOptions);
+        try {
+            const results = await this.runner.run([command]);
+            return results;
+        }
+        catch (error) {
+            this.crashCount++;
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`Application crashed: ${error.message}`, 'error');
+            }
+            // Check if we should restart
+            if (this.shouldRestart()) {
+                await this.handleCrash();
+            }
+            return [];
+        }
+    }
+    shouldRestart() {
+        if (!this.options.maxRestarts) {
+            return true;
+        }
+        return this.restartCount < this.options.maxRestarts;
+    }
+    async handleCrash() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} ${chalk_1.default.red(`${figures_1.default.cross} Application crashed`)}`, 'error');
+            logger_1.default.printLine(`${prefix} ${chalk_1.default.yellow(`${figures_1.default.warning} Attempting restart in ${this.options.restartDelay}ms...`)}`, 'info');
+        }
+        // Wait before restarting
+        await new Promise(resolve => setTimeout(resolve, this.options.restartDelay));
+        await this.gracefulRestart();
+    }
+    collectProcessStats() {
+        if (!this.options.showInfo) {
+            return;
+        }
+        const memUsage = process.memoryUsage();
+        this.processStats.memoryUsage = Math.round(memUsage.heapUsed / 1024 / 1024);
+        this.processStats.uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+        // Simple CPU usage approximation
+        const cpuUsage = process.cpuUsage();
+        this.processStats.cpuUsage = Math.round(((cpuUsage.user + cpuUsage.system) / 1000000) * 100) / 100;
+    }
+    printStartBanner() {
+        var _a, _b;
+        if (!this.options.showInfo) {
+            return;
+        }
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+        const uptimeStr = this.formatUptime(uptime);
+        console.log('\n' + chalk_1.default.bgGreen.black(`    ${(_a = this.options.runnerName) === null || _a === void 0 ? void 0 : _a.toUpperCase()} - ${(_b = this.options.environment) === null || _b === void 0 ? void 0 : _b.toUpperCase()} MODE    `) + '\n');
+        console.log(`${prefix} ${chalk_1.default.green(`${figures_1.default.tick} ${this.options.processName} started successfully`)}`);
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Runtime: ${this.options.runtime}`)}`);
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Environment: ${this.options.environment}`)}`);
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Uptime: ${uptimeStr}`)}`);
+        if (this.options.cluster) {
+            console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Cluster mode: ${this.options.clusterInstances} instances`)}`);
+        }
+        if (this.options.watch) {
+            console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Hot reload: enabled`)}`);
+        }
+        if (this.restartCount > 0) {
+            console.log(`${prefix} ${chalk_1.default.yellow(`${figures_1.default.warning} Restarts: ${this.restartCount}`)}`);
+        }
+        if (this.crashCount > 0) {
+            console.log(`${prefix} ${chalk_1.default.red(`${figures_1.default.cross} Crashes: ${this.crashCount}`)}`);
+        }
+        // Show process stats
+        this.collectProcessStats();
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Memory: ${this.processStats.memoryUsage}MB`)}`);
+        if (this.options.memoryLimit) {
+            const memoryPercent = Math.round((this.processStats.memoryUsage / this.options.memoryLimit) * 100);
+            console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Memory usage: ${memoryPercent}%`)}`);
+        }
+        console.log('');
+    }
+    formatUptime(seconds) {
+        if (seconds < 60) {
+            return `${seconds}s`;
+        }
+        else if (seconds < 3600) {
+            const minutes = Math.floor(seconds / 60);
+            const remainingSeconds = seconds % 60;
+            return `${minutes}m ${remainingSeconds}s`;
+        }
+        else {
+            const hours = Math.floor(seconds / 3600);
+            const minutes = Math.floor((seconds % 3600) / 60);
+            return `${hours}h ${minutes}m`;
+        }
+    }
+    monitorResources() {
+        if (!this.options.showInfo) {
+            return;
+        }
+        const checkInterval = setInterval(() => {
+            if (!this.isRunning) {
+                clearInterval(checkInterval);
+                return;
+            }
+            this.collectProcessStats();
+            // Check memory limit
+            if (this.options.memoryLimit && this.processStats.memoryUsage > this.options.memoryLimit) {
+                const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+                logger_1.default.printLine(`${prefix} ${chalk_1.default.red(`${figures_1.default.warning} Memory limit exceeded: ${this.processStats.memoryUsage}MB > ${this.options.memoryLimit}MB`)}`, 'warn');
+            }
+            // Log stats every 30 seconds in verbose mode
+            if (this.options.verbose && this.processStats.uptime % 30 === 0) {
+                const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+                logger_1.default.printLine(`${prefix} ${chalk_1.default.gray(`Stats: ${this.processStats.memoryUsage}MB memory, ${this.formatUptime(this.processStats.uptime)} uptime`)}`, 'info');
+            }
+        }, 1000);
+    }
+    async start() {
+        this.isRunning = true;
+        this.startTime = new Date();
+        // Setup file watcher if enabled
+        if (this.options.watch) {
+            this.setupFileWatcher();
+        }
+        // Print start banner
+        this.printStartBanner();
+        // Start file watcher if enabled
+        if (this.fileWatcher) {
+            await this.fileWatcher.start();
+        }
+        // Start resource monitoring
+        this.monitorResources();
+        // Start application
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} Starting ${this.options.processName}...`, 'info');
+        }
+        await this.startApplication();
+        // Set up graceful shutdown
+        this.setupGracefulShutdown();
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} ${this.options.processName} is running in ${this.options.environment} mode`, 'info');
+            if (this.options.watch) {
+                logger_1.default.printLine(`${prefix} Watching for changes...`, 'info');
+            }
+            logger_1.default.printLine(`${prefix} Press ${chalk_1.default.cyan('Ctrl+C')} to stop`, 'info');
+        }
+    }
+    async gracefulRestart() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (!this.isRunning) {
+            return;
+        }
+        if (!this.shouldRestart()) {
+            if (this.options.showInfo) {
+                logger_1.default.printLine(`${prefix} ${chalk_1.default.red(`${figures_1.default.cross} Max restarts reached (${this.options.maxRestarts}). Stopping application.`)}`, 'error');
+            }
+            await this.stop();
+            return;
+        }
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} ${chalk_1.default.yellow(`${figures_1.default.warning} Gracefully restarting ${this.options.processName}...`)}`, 'info');
+        }
+        this.restartCount++;
+        this.lastRestartTime = new Date();
+        // Stop current processes gracefully
+        if (this.runner) {
+            this.runner.cleanup(this.options.signal);
+        }
+        // Wait for graceful shutdown
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        // Print restart banner
+        this.printStartBanner();
+        // Start application again
+        await this.startApplication();
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} ${chalk_1.default.green(`${figures_1.default.tick} ${this.options.processName} restarted successfully`)}`, 'info');
+        }
+    }
+    async stop() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (!this.isRunning) {
+            return;
+        }
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} ${chalk_1.default.yellow(`${figures_1.default.warning} Stopping ${this.options.processName}...`)}`, 'info');
+        }
+        this.isRunning = false;
+        // Stop file watcher
+        if (this.fileWatcher) {
+            this.fileWatcher.stop();
+        }
+        // Stop application gracefully
+        if (this.runner) {
+            this.runner.cleanup(this.options.signal);
+        }
+        // Calculate final stats
+        const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+        const uptimeStr = this.formatUptime(uptime);
+        if (this.options.showInfo) {
+            logger_1.default.printLine(`${prefix} ${chalk_1.default.green(`${figures_1.default.tick} ${this.options.processName} stopped successfully`)}`, 'info');
+            logger_1.default.printLine(`${prefix} Final stats: ${uptimeStr} uptime, ${this.restartCount} restarts, ${this.crashCount} crashes`, 'info');
+        }
+    }
+    setupGracefulShutdown() {
+        const handleSignal = (signal) => {
+            if (this.options.showInfo) {
+                console.log(`\n${chalk_1.default.yellow(`${figures_1.default.warning} Received ${signal}. Gracefully shutting down ${this.options.processName}...`)}`);
+            }
+            this.stop().then(() => {
+                process.exit(0);
+            });
+        };
+        process.on('SIGINT', () => handleSignal('SIGINT'));
+        process.on('SIGTERM', () => handleSignal('SIGTERM'));
+        process.on('SIGQUIT', () => handleSignal('SIGQUIT'));
+    }
+    isActive() {
+        return this.isRunning;
+    }
+    getUptime() {
+        return Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+    }
+    getRestartCount() {
+        return this.restartCount;
+    }
+    getCrashCount() {
+        return this.crashCount;
+    }
+    getProcessStats() {
+        this.collectProcessStats();
+        return { ...this.processStats };
+    }
+    getLastRestartTime() {
+        return this.lastRestartTime;
+    }
+    getWatchedFiles() {
+        var _a;
+        return ((_a = this.fileWatcher) === null || _a === void 0 ? void 0 : _a.getWatchedFiles()) || [];
+    }
+}
+exports.StartManager = StartManager;

package/package.json

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