neex 0.1.8 → 0.2.6

package/dist/src/cli.js

@@ -3,48 +3,481 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// src/cli.ts - Main CLI file (refactored)
+// src/cli.ts - Updated version
 const commander_1 = require("commander");
-const index_js_1 = require("./commands/index.js");
+const index_js_1 = require("./index.js");
 const chalk_1 = __importDefault(require("chalk"));
 const figures_1 = __importDefault(require("figures"));
+const chokidar_1 = require("chokidar");
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const process_manager_js_1 = require("./process-manager.js");
 const { version } = require('../../package.json');
 function cli() {
     const program = new commander_1.Command();
-    // Initialize cleanup handlers
-    const cleanupHandlers = [];
+    let cleanupRunner = null;
     program
         .name('neex')
-        .description('Professional script runner with nodemon and PM2 functionality')
+        .description('Professional script runner with beautiful colored output')
         .version(version);
-    // Add all command groups
-    (0, index_js_1.addRunCommands)(program);
-    (0, index_js_1.addServerCommands)(program);
-    const devCommands = (0, index_js_1.addDevCommands)(program);
-    cleanupHandlers.push(devCommands.cleanupDev);
-    const processCommands = (0, index_js_1.addProcessCommands)(program);
-    cleanupHandlers.push(processCommands.cleanupProcess);
+    // Development command for Express.js projects
+    program
+        .command('dev <entry>')
+        .description('Run Express.js project in development mode with TypeScript support')
+        .option('-p, --port <number>', 'Port to run the server on', '3000')
+        .option('-w, --watch <path>', 'Path to watch for changes', 'src')
+        .option('-c, --no-color', 'Disable colored output')
+        .action(async (entry, options) => {
+        try {
+            const entryPath = (0, path_1.resolve)(process.cwd(), entry);
+            if (!(0, fs_1.existsSync)(entryPath)) {
+                throw new Error(`Entry file ${entry} not found`);
+            }
+            console.log(chalk_1.default.blue(`${figures_1.default.info} Starting development server...`));
+            let server = (0, child_process_1.spawn)('ts-node', [
+                '-r', 'tsconfig-paths/register',
+                entryPath
+            ], {
+                stdio: 'inherit',
+                env: {
+                    ...process.env,
+                    PORT: options.port
+                }
+            });
+            // Setup file watching
+            const watcher = (0, chokidar_1.watch)(options.watch, {
+                ignored: /(^|[\/\\])\../,
+                persistent: true
+            });
+            watcher.on('change', (path) => {
+                console.log(chalk_1.default.yellow(`${figures_1.default.info} File ${path} changed. Restarting...`));
+                server.kill();
+                server = (0, child_process_1.spawn)('ts-node', [
+                    '-r', 'tsconfig-paths/register',
+                    entryPath
+                ], {
+                    stdio: 'inherit',
+                    env: {
+                        ...process.env,
+                        PORT: options.port
+                    }
+                });
+            });
+            cleanupRunner = () => {
+                server.kill();
+                watcher.close();
+            };
+            server.on('error', (err) => {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Server error: ${err.message}`));
+                process.exit(1);
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    // Build command for TypeScript compilation
+    program
+        .command('build')
+        .description('Build TypeScript project')
+        .option('-o, --outDir <dir>', 'Output directory', 'dist')
+        .action(async (options) => {
+        try {
+            console.log(chalk_1.default.blue(`${figures_1.default.info} Building project...`));
+            const build = (0, child_process_1.spawn)('tsc', [
+                '--outDir', options.outDir
+            ], {
+                stdio: 'inherit'
+            });
+            build.on('close', (code) => {
+                if (code === 0) {
+                    console.log(chalk_1.default.green(`${figures_1.default.tick} Build completed successfully`));
+                }
+                else {
+                    console.error(chalk_1.default.red(`${figures_1.default.cross} Build failed with code ${code}`));
+                    process.exit(code !== null && code !== void 0 ? code : 1);
+                }
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    // Start command for production
+    program
+        .command('start <entry>')
+        .description('Start Express.js project in production mode')
+        .option('-p, --port <number>', 'Port to run the server on', '3000')
+        .action(async (entry, options) => {
+        try {
+            const entryPath = (0, path_1.resolve)(process.cwd(), entry);
+            if (!(0, fs_1.existsSync)(entryPath)) {
+                throw new Error(`Entry file ${entry} not found`);
+            }
+            console.log(chalk_1.default.blue(`${figures_1.default.info} Starting production server...`));
+            const server = (0, child_process_1.spawn)('node', [entryPath], {
+                stdio: 'inherit',
+                env: {
+                    ...process.env,
+                    PORT: options.port,
+                    NODE_ENV: 'production'
+                }
+            });
+            cleanupRunner = () => {
+                server.kill();
+            };
+            server.on('error', (err) => {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Server error: ${err.message}`));
+                process.exit(1);
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    // Main command for sequential execution (similar to )
+    program
+        .command('sequential <commands...>')
+        .alias('s')
+        .description('Run commands sequentially')
+        .option('-c, --no-color', 'Disable colored output')
+        .option('-t, --no-timing', 'Hide timing information')
+        .option('-p, --no-prefix', 'Hide command prefix')
+        .option('-s, --stop-on-error', 'Stop on first error')
+        .option('-o, --no-output', 'Hide command output')
+        .option('-m, --minimal', 'Use minimal output format')
+        .action(async (commands, options) => {
+        try {
+            await (0, index_js_1.run)(commands, {
+                parallel: false,
+                color: options.color,
+                showTiming: options.timing,
+                prefix: options.prefix,
+                stopOnError: options.stopOnError,
+                printOutput: options.output,
+                minimalOutput: options.minimal,
+                registerCleanup: (cleanup) => { cleanupRunner = cleanup; }
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    // runx command: parallel execution by default (with alias 'p'), can run sequentially with -q
+    program
+        .command('parallel <commands...>', { isDefault: true })
+        .alias('p')
+        .description('Run commands in parallel (default) or sequentially with -q. Alias: p')
+        .option('-c, --no-color', 'Disable colored output')
+        .option('-t, --no-timing', 'Hide timing information')
+        .option('-p, --no-prefix', 'Hide command prefix')
+        .option('-s, --stop-on-error', 'Stop on first error')
+        .option('-o, --no-output', 'Hide command output')
+        .option('-m, --minimal', 'Use minimal output format')
+        .option('-x, --max-parallel <number>', 'Maximum number of parallel processes', parseInt)
+        .option('-q, --sequential', 'Run commands sequentially instead of in parallel')
+        .action(async (commands, options) => {
+        try {
+            await (0, index_js_1.run)(commands, {
+                parallel: !options.sequential,
+                maxParallel: options.maxParallel,
+                color: options.color,
+                showTiming: options.timing,
+                prefix: options.prefix,
+                stopOnError: options.stopOnError,
+                printOutput: options.output,
+                minimalOutput: options.minimal,
+                registerCleanup: (cleanup) => { cleanupRunner = cleanup; }
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    // Process Management Commands
+    program
+        .command('startx <path>')
+        .description('Start a process with monitoring and auto-restart')
+        .option('-n, --name <name>', 'Process name')
+        .option('-w, --watch', 'Watch for file changes and auto-restart')
+        .option('-r, --max-restarts <number>', 'Maximum number of restart attempts', '5')
+        .option('-d, --restart-delay <number>', 'Delay between restarts in milliseconds', '1000')
+        .action(async (path, options) => {
+        try {
+            const process = await process_manager_js_1.processManager.startx(path, {
+                name: options.name,
+                watch: options.watch,
+                maxRestarts: parseInt(options.maxRestarts),
+                restartDelay: parseInt(options.restartDelay)
+            });
+            console.log(chalk_1.default.green(`${figures_1.default.tick} Process started successfully`));
+            console.log(chalk_1.default.blue(`ID: ${process.id}`));
+            console.log(chalk_1.default.blue(`Name: ${process.name}`));
+            console.log(chalk_1.default.blue(`PID: ${process.pid}`));
+            console.log(chalk_1.default.blue(`Max Restarts: ${process.maxRestarts}`));
+            console.log(chalk_1.default.blue(`Restart Delay: ${process.restartDelay}ms`));
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    program
+        .command('stopx <id>')
+        .description('Stop a running process')
+        .option('-f, --force', 'Force stop the process')
+        .action(async (id, options) => {
+        try {
+            await process_manager_js_1.processManager.stopx(id);
+            console.log(chalk_1.default.green(`${figures_1.default.tick} Process stopped successfully`));
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    program
+        .command('list')
+        .description('List all running processes')
+        .option('-a, --all', 'Show all processes including stopped ones')
+        .option('-j, --json', 'Output in JSON format')
+        .action((options) => {
+        const processes = process_manager_js_1.processManager.list();
+        const filteredProcesses = options.all ? processes : processes.filter(p => p.status === 'running');
+        if (filteredProcesses.length === 0) {
+            console.log(chalk_1.default.yellow(`${figures_1.default.info} No processes running`));
+            return;
+        }
+        if (options.json) {
+            console.log(JSON.stringify(filteredProcesses, null, 2));
+            return;
+        }
+        console.log(chalk_1.default.blue(`${figures_1.default.info} Running Processes:`));
+        filteredProcesses.forEach(process => {
+            const statusColor = process.status === 'running' ? 'green' :
+                process.status === 'error' ? 'red' :
+                    process.status === 'restarting' ? 'yellow' : 'gray';
+            console.log(chalk_1.default.blue(`\nID: ${process.id}`));
+            console.log(`Name: ${process.name}`);
+            console.log(`Status: ${chalk_1.default[statusColor](process.status)}`);
+            console.log(`PID: ${process.pid}`);
+            console.log(`Uptime: ${Math.floor(process.uptime)}s`);
+            console.log(`Memory: ${process.memory.toFixed(2)}MB`);
+            console.log(`Restarts: ${process.restarts}/${process.maxRestarts}`);
+            if (process.lastError) {
+                console.log(`Last Error: ${chalk_1.default.red(process.lastError)}`);
+            }
+        });
+    });
+    program
+        .command('monit <id>')
+        .description('Monitor a specific process')
+        .option('-i, --interval <number>', 'Update interval in milliseconds', '1000')
+        .action((id, options) => {
+        try {
+            const processInfo = process_manager_js_1.processManager.monit(id);
+            console.log(chalk_1.default.blue(`${figures_1.default.info} Process Monitor:`));
+            console.log(chalk_1.default.blue(`\nID: ${processInfo.id}`));
+            console.log(`Name: ${processInfo.name}`);
+            console.log(`Status: ${processInfo.status}`);
+            console.log(`PID: ${processInfo.pid}`);
+            console.log(`Uptime: ${Math.floor(processInfo.uptime)}s`);
+            console.log(`Memory: ${processInfo.memory.toFixed(2)}MB`);
+            console.log(`Restarts: ${processInfo.restarts}/${processInfo.maxRestarts}`);
+            if (processInfo.lastError) {
+                console.log(`Last Error: ${chalk_1.default.red(processInfo.lastError)}`);
+            }
+            console.log(chalk_1.default.blue(`\nRecent Logs:`));
+            processInfo.logs.forEach(log => {
+                if (log.includes('error') || log.includes('Error')) {
+                    console.log(chalk_1.default.red(log));
+                }
+                else if (log.includes('warn') || log.includes('Warn')) {
+                    console.log(chalk_1.default.yellow(log));
+                }
+                else {
+                    console.log(log);
+                }
+            });
+            // Start real-time monitoring
+            const interval = setInterval(() => {
+                try {
+                    const updatedProcess = process_manager_js_1.processManager.monit(id);
+                    process.stdout.write('\x1Bc'); // Clear screen
+                    console.log(chalk_1.default.blue(`${figures_1.default.info} Process Monitor (Live):`));
+                    console.log(chalk_1.default.blue(`\nID: ${updatedProcess.id}`));
+                    console.log(`Name: ${updatedProcess.name}`);
+                    console.log(`Status: ${updatedProcess.status}`);
+                    console.log(`PID: ${updatedProcess.pid}`);
+                    console.log(`Uptime: ${Math.floor(updatedProcess.uptime)}s`);
+                    console.log(`Memory: ${updatedProcess.memory.toFixed(2)}MB`);
+                    console.log(`Restarts: ${updatedProcess.restarts}/${updatedProcess.maxRestarts}`);
+                    if (updatedProcess.lastError) {
+                        console.log(`Last Error: ${chalk_1.default.red(updatedProcess.lastError)}`);
+                    }
+                    console.log(chalk_1.default.blue(`\nRecent Logs:`));
+                    updatedProcess.logs.forEach(log => {
+                        if (log.includes('error') || log.includes('Error')) {
+                            console.log(chalk_1.default.red(log));
+                        }
+                        else if (log.includes('warn') || log.includes('Warn')) {
+                            console.log(chalk_1.default.yellow(log));
+                        }
+                        else {
+                            console.log(log);
+                        }
+                    });
+                }
+                catch (error) {
+                    clearInterval(interval);
+                    console.error(chalk_1.default.red(`${figures_1.default.cross} Error monitoring process: ${error}`));
+                    process.exit(1);
+                }
+            }, parseInt(options.interval));
+            // Handle cleanup
+            process.on('SIGINT', () => {
+                clearInterval(interval);
+                process.exit(0);
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+    program
+        .command('log <id>')
+        .description('View process logs')
+        .option('-l, --lines <number>', 'Number of lines to show', '100')
+        .option('-f, --follow', 'Follow log output')
+        .option('-e, --error', 'Show only error logs')
+        .option('-w, --warn', 'Show only warning logs')
+        .action((id, options) => {
+        try {
+            const logs = process_manager_js_1.processManager.log(id, parseInt(options.lines));
+            if (options.error) {
+                const errorLogs = logs.filter(log => log.toLowerCase().includes('error') ||
+                    log.toLowerCase().includes('exception'));
+                console.log(chalk_1.default.blue(`${figures_1.default.info} Error Logs:`));
+                errorLogs.forEach(log => console.log(chalk_1.default.red(log)));
+                return;
+            }
+            if (options.warn) {
+                const warnLogs = logs.filter(log => log.toLowerCase().includes('warn') ||
+                    log.toLowerCase().includes('warning'));
+                console.log(chalk_1.default.blue(`${figures_1.default.info} Warning Logs:`));
+                warnLogs.forEach(log => console.log(chalk_1.default.yellow(log)));
+                return;
+            }
+            console.log(chalk_1.default.blue(`${figures_1.default.info} Process Logs:`));
+            logs.forEach(log => {
+                if (log.includes('error') || log.includes('Error')) {
+                    console.log(chalk_1.default.red(log));
+                }
+                else if (log.includes('warn') || log.includes('Warn')) {
+                    console.log(chalk_1.default.yellow(log));
+                }
+                else {
+                    console.log(log);
+                }
+            });
+            if (options.follow) {
+                const watcher = (0, chokidar_1.watch)(process_manager_js_1.processManager.getLogPath(id), {
+                    persistent: true
+                });
+                watcher.on('change', () => {
+                    const newLogs = process_manager_js_1.processManager.log(id, 1);
+                    if (newLogs.length > 0) {
+                        const log = newLogs[0];
+                        if (log.includes('error') || log.includes('Error')) {
+                            console.log(chalk_1.default.red(log));
+                        }
+                        else if (log.includes('warn') || log.includes('Warn')) {
+                            console.log(chalk_1.default.yellow(log));
+                        }
+                        else {
+                            console.log(log);
+                        }
+                    }
+                });
+                process.on('SIGINT', () => {
+                    watcher.close();
+                    process.exit(0);
+                });
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown error occurred`));
+            }
+            process.exit(1);
+        }
+    });
     program.parse(process.argv);
     // Show help if no commands specified
     if (program.args.length === 0) {
         program.help();
     }
     // Graceful shutdown handling
-    const handleSignal = async (signal) => {
+    const handleSignal = (signal) => {
         console.log(`\n${chalk_1.default.yellow(`${figures_1.default.warning} Received ${signal}. Cleaning up...`)}`);
-        // Run all cleanup handlers
-        for (const cleanup of cleanupHandlers) {
-            try {
-                await cleanup();
-            }
-            catch (error) {
-                console.error(`Cleanup error:`, error);
-            }
+        if (cleanupRunner) {
+            cleanupRunner();
         }
+        // Give cleanup a moment, then exit
         setTimeout(() => process.exit(0), 500);
     };
-    process.on('SIGINT', () => handleSignal('SIGINT').catch(err => console.error('SIGINT handler error:', err)));
-    process.on('SIGTERM', () => handleSignal('SIGTERM').catch(err => console.error('SIGTERM handler error:', err)));
-    process.on('SIGQUIT', () => handleSignal('SIGQUIT').catch(err => console.error('SIGQUIT handler error:', err)));
+    process.on('SIGINT', () => handleSignal('SIGINT')); // Ctrl+C
+    process.on('SIGTERM', () => handleSignal('SIGTERM'));
+    process.on('SIGQUIT', () => handleSignal('SIGQUIT'));
 }
 exports.default = cli;

package/dist/src/index.js

@@ -23,9 +23,7 @@ async function run(commands, options) {
         stopOnError: (_f = options === null || options === void 0 ? void 0 : options.stopOnError) !== null && _f !== void 0 ? _f : false,
         minimalOutput: (_g = options === null || options === void 0 ? void 0 : options.minimalOutput) !== null && _g !== void 0 ? _g : false,
         groupOutput: (_h = options === null || options === void 0 ? void 0 : options.groupOutput) !== null && _h !== void 0 ? _h : false,
-        isServerMode: (_j = options === null || options === void 0 ? void 0 : options.isServerMode) !== null && _j !== void 0 ? _j : false,
-        retry: options === null || options === void 0 ? void 0 : options.retry,
-        retryDelay: options === null || options === void 0 ? void 0 : options.retryDelay
+        isServerMode: (_j = options === null || options === void 0 ? void 0 : options.isServerMode) !== null && _j !== void 0 ? _j : false
     };
     const runner = new runner_1.Runner(runOptions);
     if (options === null || options === void 0 ? void 0 : options.registerCleanup) {

package/dist/src/logger.js

@@ -7,7 +7,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const chalk_1 = __importDefault(require("chalk"));
 const figures_1 = __importDefault(require("figures"));
 const string_width_1 = __importDefault(require("string-width"));
-const utils_1 = require("./utils");
 class Logger {
     constructor() {
         this.prefixLength = 0;
@@ -121,9 +120,6 @@ class Logger {
         // Clear buffer after printing
         this.outputBuffer.set(command, []);
     }
-    clearBuffer(command) {
-        this.outputBuffer.set(command, []);
-    }
     printLine(message, level = 'info') {
         if (level === 'error') {
             console.error(chalk_1.default.red(`${figures_1.default.cross} ${message}`));
@@ -140,12 +136,6 @@ class Logger {
         this.startTimes.set(command, new Date());
         const prefix = this.formatPrefix(command);
         const color = this.commandColors.get(command) || chalk_1.default.white;
-        // Stop any previous spinner for this command (e.g. if retrying)
-        this.stopSpinner(command);
-        // Clear the line before printing "Starting..."
-        if (this.isSpinnerActive) { // Check if any spinner was active to avoid clearing unnecessarily
-            process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80) + '\r');
-        }
         console.log(`${prefix} ${color('Starting...')}`);
         // Start spinner for this command
         this.startSpinner(command);
@@ -207,32 +197,6 @@ class Logger {
             console.error(`${prefix} ${chalk_1.default.red(error.message)}`);
         }
     }
-    printEnd(result, minimalOutput) {
-        this.stopSpinner(result.command);
-        const prefix = this.formatPrefix(result.command); // Corrected to formatPrefix
-        let durationDisplay = '';
-        if (result.duration !== null) {
-            // Ensure result.duration is treated as a number here
-            durationDisplay = `(${(0, utils_1.formatDuration)(result.duration)})`;
-        }
-        const duration = durationDisplay;
-        if (minimalOutput) {
-            if (!result.success) {
-                const status = result.code !== null ? `failed (code ${result.code})` : 'failed';
-                this.printLine(`${prefix} ${chalk_1.default.red(figures_1.default.cross)} ${result.command} ${status} ${duration}`, 'error');
-            }
-        }
-        else {
-            if (result.success) {
-                this.printLine(`${prefix} ${chalk_1.default.green(figures_1.default.tick)} Command "${result.command}" finished successfully ${duration}`, 'info');
-            }
-            else {
-                const errorCode = result.code !== null ? ` (code ${result.code})` : '';
-                const errorMessage = result.error ? `: ${result.error.message}` : '';
-                this.printLine(`${prefix} ${chalk_1.default.red(figures_1.default.cross)} Command "${result.command}" failed${errorCode}${errorMessage} ${duration}`, 'error');
-            }
-        }
-    }
     printSummary(results) {
         // Stop any remaining spinners
         this.stopAllSpinners();