neex 0.4.4 → 0.5.0

package/dist/src/commands/run-commands.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRunCommands = void 0;
+const index_js_1 = require("../index.js");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+function addRunCommands(program) {
+    let cleanupRunner = null;
+    // Main command for sequential execution (similar to run-s)
+    program
+        .command("s <commands...>")
+        .alias("seq")
+        .alias("sequential")
+        .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("p <commands...>", { isDefault: true })
+        .alias("par")
+        .alias("parallel")
+        .description("Run commands in parallel (default) or sequentially with -q. This is the default command.")
+        .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")
+        .option("--retry <count>", "Number of times to retry a failed command", parseInt)
+        .option("--retry-delay <ms>", "Delay in milliseconds between retries", parseInt)
+        .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,
+                retry: options.retry,
+                retryDelay: options.retryDelay,
+                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);
+        }
+    });
+}
+exports.addRunCommands = addRunCommands;

package/dist/src/commands/server-commands.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addServerCommands = void 0;
+const index_js_1 = require("../index.js");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+function addServerCommands(program) {
+    let cleanupRunner = null;
+    // Servers command specifically optimized for running web servers
+    program
+        .command('servers <commands...>')
+        .alias('srv')
+        .description('Run multiple servers with optimized output for API, frontend, etc.')
+        .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 when any server crashes')
+        .option('-x, --max-parallel <number>', 'Maximum number of parallel servers', parseInt)
+        .option('-g, --group-output', 'Group outputs by server')
+        .action(async (commands, options) => {
+        try {
+            console.log(chalk_1.default.blue(`${figures_1.default.info} Starting servers in parallel mode...`));
+            await (0, index_js_1.run)(commands, {
+                parallel: true,
+                maxParallel: options.maxParallel,
+                color: options.color,
+                showTiming: options.timing,
+                prefix: options.prefix,
+                stopOnError: options.stopOnError,
+                printOutput: true,
+                registerCleanup: (cleanup) => { cleanupRunner = cleanup; },
+                groupOutput: options.groupOutput,
+                isServerMode: true
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} Server Error: ${error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`${figures_1.default.cross} An unknown server error occurred`));
+            }
+            process.exit(1);
+        }
+    });
+}
+exports.addServerCommands = addServerCommands;

package/dist/src/dev-runner.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevRunner = void 0;
+// src/dev-runner.ts - Development runner with file watching (nodemon functionality)
+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"));
+class DevRunner {
+    constructor(options) {
+        this.commands = [];
+        this.isRunning = false;
+        this.restartCount = 0;
+        this.startTime = new Date();
+        const defaultOptions = {
+            parallel: false,
+            printOutput: true,
+            color: true,
+            showTiming: true,
+            prefix: true,
+            stopOnError: false,
+            minimalOutput: false,
+            groupOutput: false,
+            isServerMode: false,
+            restartOnChange: true,
+            clearConsole: false,
+            signal: 'SIGTERM',
+            watch: ['./'],
+            ignore: [
+                'node_modules/**',
+                '.git/**',
+                '*.log',
+                'dist/**',
+                'build/**',
+                'coverage/**',
+                '.nyc_output/**',
+                '*.tmp',
+                '*.temp'
+            ],
+            ext: ['js', 'mjs', 'json', 'ts', 'tsx', 'jsx'],
+            delay: 1000,
+            verbose: false,
+            runnerName: 'watch', // Default runner name if not specified
+        };
+        this.options = {
+            ...defaultOptions,
+            ...options
+        };
+    }
+    setupFileWatcher() {
+        const watchOptions = {
+            watch: this.options.watch || ['./'],
+            ignore: this.options.ignore,
+            ext: this.options.ext,
+            delay: this.options.delay,
+            verbose: this.options.verbose
+        };
+        this.fileWatcher = new watcher_1.FileWatcher(watchOptions);
+        this.fileWatcher.on('change', (event) => {
+            if (this.options.restartOnChange && this.isRunning) {
+                this.handleFileChange(event);
+            }
+        });
+    }
+    async handleFileChange(event) {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        logger_1.default.printLine(`${prefix} File changed: ${chalk_1.default.yellow(event.relativePath)}`, 'info');
+        if (this.options.clearConsole) {
+            console.clear();
+        }
+        await this.restart();
+    }
+    async runCommands() {
+        if (this.commands.length === 0) {
+            return [];
+        }
+        this.runner = new runner_1.Runner(this.options);
+        try {
+            const results = await this.runner.run(this.commands);
+            return results;
+        }
+        catch (error) {
+            logger_1.default.printLine(`Execution failed: ${error.message}`, 'error');
+            return [];
+        }
+    }
+    printDevBanner() {
+        var _a, _b;
+        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()} MODE    `) + '\n');
+        if (this.restartCount > 0) {
+            console.log(`${prefix} ${chalk_1.default.green(`${figures_1.default.arrowUp} Restarted ${this.restartCount} times`)}`);
+        }
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Uptime: ${uptimeStr}`)}`);
+        console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Watching: ${((_b = this.options.watch) === null || _b === void 0 ? void 0 : _b.join(', ')) || 'current directory'}`)}`);
+        if (this.options.ext && this.options.ext.length > 0) {
+            console.log(`${prefix} ${chalk_1.default.blue(`${figures_1.default.info} Extensions: ${this.options.ext.join(', ')}`)}`);
+        }
+        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`;
+        }
+    }
+    async start(commands) {
+        this.commands = commands;
+        this.isRunning = true;
+        this.startTime = new Date();
+        // Setup file watcher
+        this.setupFileWatcher();
+        // Print development banner
+        this.printDevBanner();
+        // Start file watcher
+        if (this.fileWatcher) {
+            await this.fileWatcher.start();
+        }
+        // Run initial commands
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        logger_1.default.printLine(`${prefix} Starting development server...`, 'info');
+        await this.runCommands();
+        // Set up graceful shutdown
+        this.setupGracefulShutdown();
+        logger_1.default.printLine(`${prefix} Development server started. Watching for changes...`, 'info');
+        logger_1.default.printLine(`${prefix} Press ${chalk_1.default.cyan('Ctrl+C')} to stop`, 'info');
+    }
+    async restart() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (!this.isRunning) {
+            return;
+        }
+        logger_1.default.printLine(`${prefix} Restarting due to file changes...`, 'info');
+        this.restartCount++;
+        // Stop current processes
+        if (this.runner) {
+            this.runner.cleanup(this.options.signal);
+        }
+        // Wait a moment before restarting
+        await new Promise(resolve => setTimeout(resolve, 500));
+        // Print restart banner
+        this.printDevBanner();
+        // Run commands again
+        await this.runCommands();
+        logger_1.default.printLine(`${prefix} Restart completed. Watching for changes...`, 'info');
+    }
+    async stop() {
+        const prefix = chalk_1.default.cyan(`[${this.options.runnerName}]`);
+        if (!this.isRunning) {
+            return;
+        }
+        logger_1.default.printLine(`${prefix} Stopping development server...`, 'info');
+        this.isRunning = false;
+        // Stop file watcher
+        if (this.fileWatcher) {
+            this.fileWatcher.stop();
+        }
+        // Stop current processes
+        if (this.runner) {
+            this.runner.cleanup(this.options.signal);
+        }
+        const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+        const uptimeStr = this.formatUptime(uptime);
+        logger_1.default.printLine(`${prefix} ${this.options.runnerName} development server stopped after ${uptimeStr}`, 'info');
+        if (this.restartCount > 0) {
+            logger_1.default.printLine(`${prefix} Total restarts: ${this.restartCount}`, 'info');
+        }
+    }
+    setupGracefulShutdown() {
+        const handleSignal = (signal) => {
+            console.log(`\n${chalk_1.default.yellow(`${figures_1.default.warning} Received ${signal}. Shutting down development server...`)}`);
+            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;
+    }
+    getWatchedFiles() {
+        var _a;
+        return ((_a = this.fileWatcher) === null || _a === void 0 ? void 0 : _a.getWatchedFiles()) || [];
+    }
+}
+exports.DevRunner = DevRunner;

package/dist/src/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runServers = exports.runSequential = exports.runParallel = exports.run = void 0;
+// src/index.ts - Updated version
+const runner_1 = require("./runner");
+const logger_1 = __importDefault(require("./logger"));
+/**
+ * Run one or more commands in parallel or sequentially
+ */
+async function run(commands, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const cmdArray = Array.isArray(commands) ? commands : [commands];
+    const runOptions = {
+        parallel: (_a = options === null || options === void 0 ? void 0 : options.parallel) !== null && _a !== void 0 ? _a : false,
+        maxParallel: options === null || options === void 0 ? void 0 : options.maxParallel,
+        printOutput: (_b = options === null || options === void 0 ? void 0 : options.printOutput) !== null && _b !== void 0 ? _b : true,
+        color: (_c = options === null || options === void 0 ? void 0 : options.color) !== null && _c !== void 0 ? _c : true,
+        showTiming: (_d = options === null || options === void 0 ? void 0 : options.showTiming) !== null && _d !== void 0 ? _d : true,
+        prefix: (_e = options === null || options === void 0 ? void 0 : options.prefix) !== null && _e !== void 0 ? _e : true,
+        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
+    };
+    const runner = new runner_1.Runner(runOptions);
+    if (options === null || options === void 0 ? void 0 : options.registerCleanup) {
+        options.registerCleanup(() => runner.cleanup());
+    }
+    const results = await runner.run(cmdArray);
+    if (runOptions.printOutput && cmdArray.length > 1) {
+        logger_1.default.printSummary(results);
+    }
+    return results;
+}
+exports.run = run;
+/**
+ * Run multiple commands in parallel
+ */
+async function runParallel(commands, options) {
+    return run(commands, { ...options, parallel: true });
+}
+exports.runParallel = runParallel;
+/**
+ * Run multiple commands sequentially
+ */
+async function runSequential(commands, options) {
+    return run(commands, { ...options, parallel: false });
+}
+exports.runSequential = runSequential;
+/**
+ * Run multiple servers with optimized output
+ */
+async function runServers(commands, options) {
+    return run(commands, {
+        ...options,
+        parallel: true,
+        isServerMode: true,
+        printOutput: true
+    });
+}
+exports.runServers = runServers;
+exports.default = {
+    run,
+    runParallel,
+    runSequential,
+    runServers
+};

package/dist/{logger.js → src/logger.js}

@@ -7,6 +7,7 @@ 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;
@@ -120,6 +121,9 @@ 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}`));
@@ -136,6 +140,12 @@ 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);
@@ -197,6 +207,32 @@ 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();
@@ -235,4 +271,3 @@ class Logger {
     }
 }
 exports.default = Logger.getInstance();
-//# sourceMappingURL=logger.js.map