neex 0.3.6 → 0.3.8

package/dist/src/runner.js

@@ -1,320 +0,0 @@
-"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.Runner = void 0;
-// src/runner.ts - Updated version
-const child_process_1 = require("child_process");
-const fsPromises = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
-const chalk_1 = __importDefault(require("chalk"));
-const logger_1 = __importDefault(require("./logger"));
-const p_map_1 = __importDefault(require("p-map"));
-const npm_run_path_1 = __importDefault(require("npm-run-path"));
-class Runner {
-    constructor(options) {
-        this.activeProcesses = new Map();
-        this.serverInfo = new Map();
-        this.portRegex = /listening on (?:port |http:\/\/localhost:|https:\/\/localhost:)(\d+)/i;
-        this.urlRegex = /(https?:\/\/localhost:[0-9]+(?:\/[^\s]*)?)/i;
-        this.options = options;
-        this.activeProcesses = new Map();
-    }
-    async resolveScriptAndCwd(scriptNameOrCommand, baseDir) {
-        try {
-            const packageJsonPath = path.join(baseDir, 'package.json');
-            const packageJsonContent = await fsPromises.readFile(packageJsonPath, 'utf-8');
-            const packageJson = JSON.parse(packageJsonContent);
-            if (packageJson.scripts && packageJson.scripts[scriptNameOrCommand]) {
-                const scriptValue = packageJson.scripts[scriptNameOrCommand];
-                const cdMatch = scriptValue.match(/^cd\s+([^&]+)\s+&&\s+(.*)$/);
-                if (cdMatch) {
-                    const dir = cdMatch[1];
-                    const commandToExecute = cdMatch[2];
-                    const targetCwd = path.resolve(baseDir, dir);
-                    return { executableCommand: commandToExecute, executionCwd: targetCwd };
-                }
-                else {
-                    // It's a script from package.json, but no 'cd ... && ...' pattern
-                    return { executableCommand: scriptValue, executionCwd: baseDir };
-                }
-            }
-        }
-        catch (error) {
-            // Errors like package.json not found, or script not in package.json
-            // Will treat as direct command
-        }
-        return { executableCommand: scriptNameOrCommand, executionCwd: undefined };
-    }
-    detectServerInfo(command, data) {
-        if (!this.options.isServerMode)
-            return;
-        // Get or create server info
-        let serverInfo = this.serverInfo.get(command);
-        if (!serverInfo) {
-            serverInfo = {
-                name: command,
-                status: 'starting'
-            };
-            this.serverInfo.set(command, serverInfo);
-        }
-        // Try to detect port from output
-        const portMatch = data.match(this.portRegex);
-        if (portMatch && portMatch[1]) {
-            serverInfo.port = parseInt(portMatch[1], 10);
-            serverInfo.status = 'running';
-            // Only log if we just discovered the port
-            if (!serverInfo.url) {
-                logger_1.default.printLine(`Server ${command} running on port ${serverInfo.port}`, 'info');
-            }
-        }
-        // Try to detect full URL from output
-        const urlMatch = data.match(this.urlRegex);
-        if (urlMatch && urlMatch[1]) {
-            serverInfo.url = urlMatch[1];
-            serverInfo.status = 'running';
-            // Log the full URL once we detect it
-            logger_1.default.printLine(`Server ${command} available at ${chalk_1.default.cyan(serverInfo.url)}`, 'info');
-        }
-        // Update server info
-        this.serverInfo.set(command, serverInfo);
-    }
-    async runCommand(originalCommand) {
-        const { executableCommand: command, executionCwd: cwd } = await this.resolveScriptAndCwd(originalCommand, process.cwd());
-        const startTime = new Date();
-        const result = {
-            command: originalCommand,
-            success: false,
-            code: null,
-            startTime,
-            endTime: null,
-            output: []
-        };
-        if (this.options.printOutput) {
-            logger_1.default.printStart(originalCommand);
-        }
-        return new Promise((resolve) => {
-            const [cmd, ...args] = command.split(' ');
-            const env = {
-                ...process.env,
-                ...npm_run_path_1.default.env(),
-                FORCE_COLOR: this.options.color ? '1' : '0'
-            };
-            const proc = (0, child_process_1.spawn)(cmd, args, {
-                stdio: ['ignore', 'pipe', 'pipe'],
-                shell: true,
-                env,
-                detached: true,
-                cwd
-            });
-            this.activeProcesses.set(originalCommand, proc);
-            if (this.options.isServerMode) {
-                this.serverInfo.set(originalCommand, {
-                    name: originalCommand,
-                    status: 'starting',
-                    pid: proc.pid,
-                    startTime: new Date()
-                });
-            }
-            // Capture and display output
-            if (this.options.printOutput) {
-                proc.stdout.on('data', (data) => {
-                    const output = {
-                        command: originalCommand,
-                        type: 'stdout',
-                        data: data.toString(),
-                        timestamp: new Date()
-                    };
-                    if (this.options.isServerMode) {
-                        this.detectServerInfo(originalCommand, data.toString());
-                    }
-                    // Store output for logging
-                    if (result.output)
-                        result.output.push(output);
-                    logger_1.default.bufferOutput(output);
-                    // Print immediately unless we're in group mode
-                    if (!this.options.groupOutput) {
-                        logger_1.default.printBuffer(originalCommand);
-                    }
-                });
-                proc.stderr.on('data', (data) => {
-                    const output = {
-                        command: originalCommand,
-                        type: 'stderr',
-                        data: data.toString(),
-                        timestamp: new Date()
-                    };
-                    // Store output for logging
-                    if (result.output)
-                        result.output.push(output);
-                    logger_1.default.bufferOutput(output);
-                    // Print immediately unless we're in group mode
-                    if (!this.options.groupOutput) {
-                        logger_1.default.printBuffer(originalCommand);
-                    }
-                });
-            }
-            proc.on('close', (code) => {
-                const endTime = new Date();
-                const duration = endTime.getTime() - startTime.getTime();
-                result.endTime = endTime;
-                result.duration = duration;
-                result.code = code;
-                result.success = code === 0;
-                this.activeProcesses.delete(originalCommand);
-                if (this.options.isServerMode) {
-                    const serverInfo = this.serverInfo.get(originalCommand);
-                    if (serverInfo) {
-                        serverInfo.status = code === 0 ? 'stopped' : 'error';
-                        this.serverInfo.set(originalCommand, serverInfo);
-                    }
-                    // If this is server mode and a server failed, print prominent error
-                    if (code !== 0) {
-                        logger_1.default.printLine(`Server ${originalCommand} crashed with code ${code}`, 'error');
-                    }
-                }
-                // Print grouped output at the end if enabled
-                if (this.options.groupOutput && result.output && result.output.length > 0) {
-                    logger_1.default.printBuffer(originalCommand);
-                }
-                if (this.options.printOutput) {
-                    if (result.success) {
-                        logger_1.default.printSuccess(result);
-                    }
-                    else {
-                        logger_1.default.printError(result);
-                    }
-                }
-                resolve(result);
-            });
-            proc.on('error', (error) => {
-                const endTime = new Date();
-                const duration = endTime.getTime() - startTime.getTime();
-                result.endTime = endTime;
-                result.duration = duration;
-                result.error = error;
-                result.success = false;
-                this.activeProcesses.delete(originalCommand);
-                if (this.options.isServerMode) {
-                    const serverInfo = this.serverInfo.get(originalCommand);
-                    if (serverInfo) {
-                        serverInfo.status = 'error';
-                        this.serverInfo.set(originalCommand, serverInfo);
-                    }
-                }
-                if (this.options.printOutput) {
-                    logger_1.default.printError(result);
-                }
-                resolve(result);
-            });
-        });
-    }
-    async runSequential(commands) {
-        const results = [];
-        for (const cmd of commands) {
-            const result = await this.runCommand(cmd);
-            results.push(result);
-            // Stop on error if enabled
-            if (!result.success && this.options.stopOnError) {
-                break;
-            }
-        }
-        return results;
-    }
-    async runParallel(commands) {
-        const concurrency = this.options.maxParallel || commands.length;
-        const mapper = async (cmd) => {
-            return this.runCommand(cmd);
-        };
-        try {
-            return await (0, p_map_1.default)(commands, mapper, {
-                concurrency,
-                stopOnError: this.options.stopOnError
-            });
-        }
-        catch (error) {
-            // If pMap stops due to stopOnError
-            if (this.options.isServerMode) {
-                logger_1.default.printLine('One or more servers failed to start. Stopping all servers.', 'error');
-            }
-            return [];
-        }
-    }
-    async run(commands) {
-        if (commands.length === 0) {
-            return [];
-        }
-        // Set up logger with commands
-        logger_1.default.setCommands(commands);
-        // Run in parallel or sequential mode
-        if (this.options.parallel) {
-            if (this.options.isServerMode) {
-                logger_1.default.printLine('Starting servers in parallel mode', 'info');
-            }
-            return this.runParallel(commands);
-        }
-        else {
-            if (this.options.isServerMode) {
-                logger_1.default.printLine('Starting servers in sequential mode', 'info');
-            }
-            return this.runSequential(commands);
-        }
-    }
-    cleanup(signal = 'SIGTERM') {
-        logger_1.default.printLine('Cleaning up child processes...', 'warn');
-        this.activeProcesses.forEach((proc, command) => {
-            if (proc.pid && !proc.killed) {
-                try {
-                    // Kill process group
-                    process.kill(-proc.pid, signal);
-                    logger_1.default.printLine(`Sent ${signal} to process group ${proc.pid} (${command})`, 'info');
-                }
-                catch (e) {
-                    // Fallback if killing group failed
-                    try {
-                        proc.kill(signal);
-                        logger_1.default.printLine(`Sent ${signal} to process ${proc.pid} (${command})`, 'info');
-                    }
-                    catch (errInner) {
-                        logger_1.default.printLine(`Failed to kill process ${proc.pid} (${command}): ${errInner.message}`, 'error');
-                    }
-                }
-            }
-        });
-        this.activeProcesses.clear();
-        // Print server status summary if in server mode
-        if (this.options.isServerMode && this.serverInfo.size > 0) {
-            logger_1.default.printLine('Server shutdown summary:', 'info');
-            this.serverInfo.forEach((info, command) => {
-                const statusColor = info.status === 'running' ? chalk_1.default.green :
-                    info.status === 'error' ? chalk_1.default.red : chalk_1.default.yellow;
-                logger_1.default.printLine(`  ${command}: ${statusColor(info.status)}`, 'info');
-            });
-        }
-    }
-}
-exports.Runner = Runner;

package/dist/src/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });