neex 0.1.3 → 0.1.5

package/dist/src/dev-runner.js

@@ -0,0 +1,203 @@
+"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,
+        };
+        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) {
+        logger_1.default.printLine(`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;
+        const uptime = Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+        const uptimeStr = this.formatUptime(uptime);
+        console.log('\n' + chalk_1.default.bgGreen.black('         DEV MODE         ') + '\n');
+        if (this.restartCount > 0) {
+            console.log(chalk_1.default.green(`${figures_1.default.arrowUp} Restarted ${this.restartCount} times`));
+        }
+        console.log(chalk_1.default.blue(`${figures_1.default.info} Uptime: ${uptimeStr}`));
+        console.log(chalk_1.default.blue(`${figures_1.default.info} Watching: ${((_a = this.options.watch) === null || _a === void 0 ? void 0 : _a.join(', ')) || 'current directory'}`));
+        if (this.options.ext && this.options.ext.length > 0) {
+            console.log(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
+        logger_1.default.printLine('Starting development server...', 'info');
+        await this.runCommands();
+        // Set up graceful shutdown
+        this.setupGracefulShutdown();
+        logger_1.default.printLine('Development server started. Watching for changes...', 'info');
+        logger_1.default.printLine(`Press ${chalk_1.default.cyan('Ctrl+C')} to stop`, 'info');
+    }
+    async restart() {
+        if (!this.isRunning) {
+            return;
+        }
+        logger_1.default.printLine('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('Restart completed. Watching for changes...', 'info');
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        logger_1.default.printLine('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(`Development server stopped after ${uptimeStr}`, 'info');
+        if (this.restartCount > 0) {
+            logger_1.default.printLine(`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

@@ -23,7 +23,9 @@ 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
+        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) {

package/dist/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();

package/dist/src/process-manager.js

@@ -0,0 +1,330 @@
+"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.ProcessManager = void 0;
+// src/process-manager.ts - PM2 alternative process manager
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const events_1 = require("events");
+const logger_1 = __importDefault(require("./logger"));
+class ProcessManager extends events_1.EventEmitter {
+    constructor(configPath) {
+        super();
+        this.processes = new Map();
+        this.isMonitoring = false;
+        this.configPath = configPath || path.join(process.cwd(), '.neex', 'processes.json');
+        this.ensureConfigDir();
+        this.startMonitoring();
+    }
+    async ensureConfigDir() {
+        const dir = path.dirname(this.configPath);
+        try {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        catch (error) {
+            // Directory might already exist
+        }
+    }
+    async saveConfig() {
+        try {
+            const config = Array.from(this.processes.values()).map(proc => ({
+                ...proc.config,
+                status: proc.status,
+                created_at: proc.created_at,
+                restarts: proc.restarts
+            }));
+            await fs.writeFile(this.configPath, JSON.stringify(config, null, 2));
+        }
+        catch (error) {
+            logger_1.default.printLine(`Failed to save config: ${error.message}`, 'error');
+        }
+    }
+    async loadConfig() {
+        try {
+            const data = await fs.readFile(this.configPath, 'utf-8');
+            const configs = JSON.parse(data);
+            for (const config of configs) {
+                if (config.id && !this.processes.has(config.id)) {
+                    const processInfo = {
+                        id: config.id,
+                        name: config.name,
+                        status: 'stopped',
+                        uptime: 0,
+                        restarts: 0,
+                        memory: 0,
+                        cpu: 0,
+                        created_at: new Date(),
+                        config
+                    };
+                    this.processes.set(config.id, processInfo);
+                }
+            }
+        }
+        catch (error) {
+            // Config file might not exist yet
+        }
+    }
+    generateId(name) {
+        let id = name.toLowerCase().replace(/[^a-z0-9]/g, '-');
+        let counter = 0;
+        while (this.processes.has(id)) {
+            counter++;
+            id = `${name.toLowerCase().replace(/[^a-z0-9]/g, '-')}-${counter}`;
+        }
+        return id;
+    }
+    async startProcess(processInfo) {
+        const { config } = processInfo;
+        try {
+            processInfo.status = 'launching';
+            this.emit('process:launching', processInfo);
+            const args = config.args || [];
+            const env = {
+                ...process.env,
+                ...config.env,
+                NEEX_PROCESS_ID: processInfo.id,
+                NEEX_PROCESS_NAME: processInfo.name
+            };
+            const childProcess = (0, child_process_1.spawn)(config.script, args, {
+                cwd: config.cwd || process.cwd(),
+                env,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                detached: true
+            });
+            processInfo.process = childProcess;
+            processInfo.pid = childProcess.pid;
+            processInfo.status = 'online';
+            processInfo.created_at = new Date();
+            this.emit('process:start', processInfo);
+            // Handle stdout
+            if (childProcess.stdout) {
+                childProcess.stdout.on('data', (data) => {
+                    this.emit('process:log', {
+                        id: processInfo.id,
+                        type: 'stdout',
+                        data: data.toString()
+                    });
+                });
+            }
+            // Handle stderr
+            if (childProcess.stderr) {
+                childProcess.stderr.on('data', (data) => {
+                    this.emit('process:log', {
+                        id: processInfo.id,
+                        type: 'stderr',
+                        data: data.toString()
+                    });
+                });
+            }
+            // Handle process exit
+            childProcess.on('exit', (code, signal) => {
+                processInfo.status = code === 0 ? 'stopped' : 'errored';
+                processInfo.process = undefined;
+                processInfo.pid = undefined;
+                this.emit('process:exit', { processInfo, code, signal });
+                // Auto-restart if enabled
+                if (config.autorestart && processInfo.restarts < (config.max_restarts || 10)) {
+                    const delay = config.restart_delay || 1000;
+                    setTimeout(() => {
+                        if (processInfo.status !== 'stopped') {
+                            this.restart(processInfo.id);
+                        }
+                    }, delay);
+                }
+            });
+            // Handle process error
+            childProcess.on('error', (error) => {
+                processInfo.status = 'errored';
+                this.emit('process:error', { processInfo, error });
+            });
+        }
+        catch (error) {
+            processInfo.status = 'errored';
+            this.emit('process:error', { processInfo, error });
+            throw error;
+        }
+    }
+    startMonitoring() {
+        if (this.isMonitoring)
+            return;
+        this.isMonitoring = true;
+        this.monitoringInterval = setInterval(() => {
+            this.updateProcessStats();
+        }, 5000); // Update every 5 seconds
+    }
+    stopMonitoring() {
+        if (this.monitoringInterval) {
+            clearInterval(this.monitoringInterval);
+            this.monitoringInterval = undefined;
+        }
+        this.isMonitoring = false;
+    }
+    async updateProcessStats() {
+        for (const processInfo of this.processes.values()) {
+            if (processInfo.status === 'online' && processInfo.pid) {
+                try {
+                    // Update uptime
+                    const now = Date.now();
+                    processInfo.uptime = Math.floor((now - processInfo.created_at.getTime()) / 1000);
+                    // TODO: Implement memory and CPU monitoring
+                    // This would require platform-specific code or external libraries
+                    // For now, we'll set placeholder values
+                    processInfo.memory = 0;
+                    processInfo.cpu = 0;
+                }
+                catch (error) {
+                    // Process might have died
+                    if (processInfo.status === 'online') {
+                        processInfo.status = 'stopped';
+                    }
+                }
+            }
+        }
+    }
+    async start(config) {
+        const id = this.generateId(config.name);
+        const processInfo = {
+            id,
+            name: config.name,
+            status: 'stopped',
+            uptime: 0,
+            restarts: 0,
+            memory: 0,
+            cpu: 0,
+            created_at: new Date(),
+            config: { ...config, id }
+        };
+        this.processes.set(id, processInfo);
+        await this.startProcess(processInfo);
+        await this.saveConfig();
+        return id;
+    }
+    async stop(id) {
+        const processInfo = this.processes.get(id);
+        if (!processInfo) {
+            throw new Error(`Process ${id} not found`);
+        }
+        if (processInfo.status === 'stopped') {
+            return;
+        }
+        processInfo.status = 'stopping';
+        if (processInfo.process && processInfo.pid) {
+            try {
+                // Try graceful shutdown first
+                processInfo.process.kill('SIGTERM');
+                // Force kill after timeout
+                setTimeout(() => {
+                    if (processInfo.process && !processInfo.process.killed) {
+                        processInfo.process.kill('SIGKILL');
+                    }
+                }, 5000);
+            }
+            catch (error) {
+                // Process might already be dead
+            }
+        }
+        processInfo.status = 'stopped';
+        processInfo.process = undefined;
+        processInfo.pid = undefined;
+        await this.saveConfig();
+        this.emit('process:stop', processInfo);
+    }
+    async restart(id) {
+        const processInfo = this.processes.get(id);
+        if (!processInfo) {
+            throw new Error(`Process ${id} not found`);
+        }
+        if (processInfo.status === 'online') {
+            await this.stop(id);
+            // Wait a bit before restarting
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        processInfo.restarts++;
+        processInfo.last_restart = new Date();
+        await this.startProcess(processInfo);
+        await this.saveConfig();
+    }
+    async delete(id) {
+        const processInfo = this.processes.get(id);
+        if (!processInfo) {
+            throw new Error(`Process ${id} not found`);
+        }
+        if (processInfo.status === 'online') {
+            await this.stop(id);
+        }
+        this.processes.delete(id);
+        await this.saveConfig();
+        this.emit('process:delete', processInfo);
+    }
+    async list() {
+        return Array.from(this.processes.values());
+    }
+    async status(id) {
+        if (id) {
+            const processInfo = this.processes.get(id);
+            if (!processInfo) {
+                throw new Error(`Process ${id} not found`);
+            }
+            return processInfo;
+        }
+        return this.list();
+    }
+    async logs(id, lines = 100) {
+        // TODO: Implement log file reading
+        // For now, return empty array
+        return [];
+    }
+    async save() {
+        await this.saveConfig();
+    }
+    async load() {
+        await this.loadConfig();
+    }
+    async stopAll() {
+        const promises = Array.from(this.processes.keys()).map(id => this.stop(id));
+        await Promise.all(promises);
+    }
+    async restartAll() {
+        const promises = Array.from(this.processes.keys()).map(id => this.restart(id));
+        await Promise.all(promises);
+    }
+    async deleteAll() {
+        await this.stopAll();
+        this.processes.clear();
+        await this.saveConfig();
+    }
+    getProcess(id) {
+        return this.processes.get(id);
+    }
+    dispose() {
+        this.stopMonitoring();
+        this.stopAll();
+    }
+}
+exports.ProcessManager = ProcessManager;