neex 0.1.7 → 0.2.5

package/dist/src/process-manager.js

@@ -1,426 +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.ProcessManager = void 0;
-// src/process-manager.ts - PM2 alternative process manager
-const child_process_1 = require("child_process");
-const fsFull = __importStar(require("fs")); // Renamed to fsFull to avoid conflicts
-const fs_1 = require("fs");
-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.logStreams = new Map();
-        this.processes = new Map();
-        this.isMonitoring = false;
-        this.configPath = configPath || path.join(process.cwd(), '.neex', 'processes.json');
-        this.logDir = path.join(path.dirname(this.configPath), 'logs');
-        this.ensureConfigDirAndLogDir(); // Renamed and updated
-        // loadConfig will be called by CLI commands as needed before operations like list, stop, etc.
-        this.startMonitoring();
-    }
-    async ensureConfigDirAndLogDir() {
-        const dir = path.dirname(this.configPath);
-        try {
-            await fs_1.promises.mkdir(dir, { recursive: true });
-            await fs_1.promises.mkdir(this.logDir, { recursive: true });
-        }
-        catch (error) {
-            logger_1.default.printLine(`Failed to create config/log directories: ${error.message}`, 'error');
-            // Directory might already exist or other error
-        }
-    }
-    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_1.promises.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_1.promises.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;
-    }
-    closeLogStreams(id) {
-        var _a, _b;
-        const streams = this.logStreams.get(id);
-        if (streams) {
-            (_a = streams.out) === null || _a === void 0 ? void 0 : _a.end();
-            (_b = streams.err) === null || _b === void 0 ? void 0 : _b.end();
-            this.logStreams.delete(id);
-        }
-    }
-    async startProcess(processInfo) {
-        const { config } = processInfo;
-        // Setup log files
-        const defaultLogPath = (type) => path.join(this.logDir, `${processInfo.id}.${type}.log`);
-        config.out_file = config.out_file || defaultLogPath('out');
-        config.error_file = config.error_file || defaultLogPath('err');
-        this.closeLogStreams(processInfo.id); // Ensure any previous streams for this ID are closed (e.g., on restart)
-        let outStream;
-        let errStream;
-        try {
-            if (config.out_file) {
-                await fs_1.promises.mkdir(path.dirname(config.out_file), { recursive: true }); // Ensure directory for custom log file exists
-                outStream = fsFull.createWriteStream(config.out_file, { flags: 'a' });
-                this.logStreams.set(processInfo.id, { ...this.logStreams.get(processInfo.id), out: outStream });
-            }
-            if (config.error_file) {
-                await fs_1.promises.mkdir(path.dirname(config.error_file), { recursive: true }); // Ensure directory for custom log file exists
-                errStream = fsFull.createWriteStream(config.error_file, { flags: 'a' });
-                this.logStreams.set(processInfo.id, { ...this.logStreams.get(processInfo.id), err: errStream });
-            }
-        }
-        catch (streamError) {
-            logger_1.default.printLine(`Failed to open log streams for ${processInfo.id}: ${streamError.message}`, 'error');
-        }
-        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();
-            // Allow parent to exit independently of the child
-            if (childProcess.pid) { // unref only if process spawned successfully
-                childProcess.unref();
-            }
-            this.emit('process:start', processInfo);
-            // Pipe to log files if streams are available
-            if (outStream && childProcess.stdout) {
-                childProcess.stdout.pipe(outStream);
-            }
-            if (errStream && childProcess.stderr) {
-                childProcess.stderr.pipe(errStream);
-            }
-            // 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;
-                // Note: Streams are not closed here on 'exit' to allow logs to be read after a crash.
-                // They are closed on explicit stop/delete or neex shutdown.
-                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;
-        this.closeLogStreams(id);
-        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);
-        }
-        const currentProcessInfo = this.processes.get(id);
-        if (currentProcessInfo) {
-            if (currentProcessInfo.status === 'online' || currentProcessInfo.status === 'launching' || currentProcessInfo.status === 'stopping') {
-                // stop() will call closeLogStreams
-            }
-            else {
-                this.closeLogStreams(id); // Ensure closed for other states before deleting
-            }
-        }
-        // Optional: Delete actual log files if `delete` implies full data removal
-        // if (config.out_file) await fsPromises.unlink(config.out_file).catch(() => {});
-        // if (config.error_file) await fsPromises.unlink(config.error_file).catch(() => {});
-        this.processes.delete(id);
-        await this.saveConfig();
-        if (currentProcessInfo)
-            this.emit('process:delete', currentProcessInfo);
-    }
-    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 = 15) {
-        let processInfo = this.processes.get(id);
-        if (!processInfo) {
-            await this.loadConfig(); // Attempt to load if not in memory
-            processInfo = this.processes.get(id);
-            if (!processInfo) {
-                throw new Error(`Process ${id} not found`);
-            }
-        }
-        return this.readLogFiles(processInfo.config, lines);
-    }
-    async readLogFiles(config, linesToRead) {
-        const finalMessages = [];
-        const { out_file, error_file } = config;
-        const readFileLastLines = async (filePath) => {
-            if (!filePath)
-                return [];
-            try {
-                await fs_1.promises.access(filePath);
-                const content = await fs_1.promises.readFile(filePath, 'utf-8');
-                const fileLines = content.split('\n').filter((line) => line.trim() !== '');
-                return fileLines.slice(-linesToRead);
-            }
-            catch (error) {
-                // Log file might not exist or not be readable, return empty
-                return [];
-            }
-        };
-        const outLogs = await readFileLastLines(out_file);
-        const errLogs = await readFileLastLines(error_file);
-        outLogs.forEach(log => finalMessages.push(log));
-        if (errLogs.length > 0 && outLogs.length > 0) {
-            finalMessages.push('--- STDERR ---'); // Separator
-        }
-        errLogs.forEach(log => finalMessages.push(log));
-        return finalMessages;
-    }
-    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);
-    }
-    async dispose() {
-        this.stopMonitoring();
-        this.stopAll();
-    }
-}
-exports.ProcessManager = ProcessManager;

package/dist/src/utils.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatDuration = void 0;
-function formatDuration(ms) {
-    if (ms < 1000) {
-        return `${ms}ms`;
-    }
-    return `${(ms / 1000).toFixed(2)}s`;
-}
-exports.formatDuration = formatDuration;

package/dist/src/watcher.js

@@ -1,245 +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.FileWatcher = void 0;
-// src/watcher.ts - File watcher for development (nodemon functionality)
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const events_1 = require("events");
-const chalk_1 = __importDefault(require("chalk"));
-const logger_1 = __importDefault(require("./logger"));
-class FileWatcher extends events_1.EventEmitter {
-    constructor(options) {
-        super();
-        this.watchers = [];
-        this.watchedFiles = new Set();
-        this.debounceTimer = null;
-        this.isWatching = false;
-        this.ignorePatterns = [];
-        // Initialize with a copy of user-provided options.
-        const processedOptions = { ...options };
-        // Apply defaults if properties were not set in the provided 'options'.
-        if (processedOptions.watch === undefined) {
-            processedOptions.watch = ['./'];
-        }
-        if (processedOptions.ignore === undefined) {
-            processedOptions.ignore = [
-                'node_modules/**',
-                '.git/**',
-                '*.log',
-                'dist/**',
-                'build/**',
-                'coverage/**',
-                '.nyc_output/**',
-                '*.tmp',
-                '*.temp'
-            ];
-        }
-        if (processedOptions.ext === undefined) {
-            processedOptions.ext = ['js', 'mjs', 'json', 'ts', 'tsx', 'jsx'];
-        }
-        if (processedOptions.delay === undefined) {
-            processedOptions.delay = 1000;
-        }
-        if (processedOptions.verbose === undefined) {
-            processedOptions.verbose = false;
-        }
-        if (processedOptions.legacyWatch === undefined) {
-            processedOptions.legacyWatch = false;
-        }
-        if (processedOptions.pollingInterval === undefined) {
-            processedOptions.pollingInterval = 1000;
-        }
-        // 'cwd' and 'env' are optional and don't have explicit defaults in this setup;
-        // they will be taken from 'options' or remain undefined if not provided.
-        this.options = processedOptions;
-        this.setupIgnorePatterns();
-    }
-    setupIgnorePatterns() {
-        this.ignorePatterns = (this.options.ignore || []).map(pattern => {
-            // Convert glob patterns to regex
-            const regexPattern = pattern
-                .replace(/\*\*/g, '.*')
-                .replace(/\*/g, '[^/]*')
-                .replace(/\?/g, '[^/]')
-                .replace(/\./g, '\\.');
-            return new RegExp(regexPattern, 'i');
-        });
-    }
-    shouldIgnoreFile(filePath) {
-        const relativePath = path.relative(process.cwd(), filePath);
-        // Check ignore patterns
-        for (const pattern of this.ignorePatterns) {
-            if (pattern.test(relativePath) || pattern.test(filePath)) {
-                return true;
-            }
-        }
-        // Check file extension
-        if (this.options.ext && this.options.ext.length > 0) {
-            const ext = path.extname(filePath).slice(1);
-            if (!this.options.ext.includes(ext)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    async isValidFile(filePath) {
-        try {
-            const stats = await fs.promises.stat(filePath);
-            return stats.isFile();
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    async watchDirectory(dirPath) {
-        try {
-            const absolutePath = path.resolve(dirPath);
-            if (this.options.verbose) {
-                logger_1.default.printLine(`Watching directory: ${chalk_1.default.cyan(absolutePath)}`, 'info');
-            }
-            const watcher = fs.watch(absolutePath, { recursive: true }, async (eventType, filename) => {
-                if (!filename)
-                    return;
-                const fullPath = path.join(absolutePath, filename);
-                if (this.shouldIgnoreFile(fullPath)) {
-                    return;
-                }
-                if (!(await this.isValidFile(fullPath))) {
-                    return;
-                }
-                this.handleFileChange(fullPath, eventType);
-            });
-            this.watchers.push(watcher);
-        }
-        catch (error) {
-            if (this.options.verbose) {
-                logger_1.default.printLine(`Failed to watch directory ${dirPath}: ${error.message}`, 'warn');
-            }
-        }
-    }
-    async watchFile(filePath) {
-        try {
-            const absolutePath = path.resolve(filePath);
-            if (this.shouldIgnoreFile(absolutePath)) {
-                return;
-            }
-            if (!(await this.isValidFile(absolutePath))) {
-                return;
-            }
-            if (this.options.verbose) {
-                logger_1.default.printLine(`Watching file: ${chalk_1.default.cyan(absolutePath)}`, 'info');
-            }
-            const watcher = fs.watch(absolutePath, (eventType) => {
-                this.handleFileChange(absolutePath, eventType);
-            });
-            this.watchers.push(watcher);
-            this.watchedFiles.add(absolutePath);
-        }
-        catch (error) {
-            if (this.options.verbose) {
-                logger_1.default.printLine(`Failed to watch file ${filePath}: ${error.message}`, 'warn');
-            }
-        }
-    }
-    handleFileChange(filePath, eventType) {
-        if (this.options.verbose) {
-            logger_1.default.printLine(`File ${eventType}: ${chalk_1.default.yellow(path.relative(process.cwd(), filePath))}`, 'info');
-        }
-        // Debounce file changes
-        if (this.debounceTimer) {
-            clearTimeout(this.debounceTimer);
-        }
-        this.debounceTimer = setTimeout(() => {
-            this.emit('change', {
-                path: filePath,
-                event: eventType,
-                relativePath: path.relative(process.cwd(), filePath)
-            });
-        }, this.options.delay);
-    }
-    async start() {
-        if (this.isWatching) {
-            return;
-        }
-        this.isWatching = true;
-        logger_1.default.printLine('Starting file watcher...', 'info');
-        for (const watchPath of this.options.watch) {
-            const absolutePath = path.resolve(watchPath);
-            try {
-                const stats = await fs.promises.stat(absolutePath);
-                if (stats.isDirectory()) {
-                    await this.watchDirectory(absolutePath);
-                }
-                else if (stats.isFile()) {
-                    await this.watchFile(absolutePath);
-                }
-            }
-            catch (error) {
-                logger_1.default.printLine(`Cannot watch ${watchPath}: ${error.message}`, 'warn');
-            }
-        }
-        const watchedCount = this.watchers.length;
-        logger_1.default.printLine(`File watcher started. Monitoring ${chalk_1.default.green(watchedCount)} locations`, 'info');
-        if (this.options.ext && this.options.ext.length > 0) {
-            logger_1.default.printLine(`Watching extensions: ${chalk_1.default.cyan(this.options.ext.join(', '))}`, 'info');
-        }
-    }
-    stop() {
-        if (!this.isWatching) {
-            return;
-        }
-        logger_1.default.printLine('Stopping file watcher...', 'info');
-        this.watchers.forEach(watcher => {
-            try {
-                watcher.close();
-            }
-            catch (error) {
-                // Ignore errors when closing watchers
-            }
-        });
-        this.watchers = [];
-        this.watchedFiles.clear();
-        this.isWatching = false;
-        if (this.debounceTimer) {
-            clearTimeout(this.debounceTimer);
-            this.debounceTimer = null;
-        }
-        logger_1.default.printLine('File watcher stopped', 'info');
-    }
-    isActive() {
-        return this.isWatching;
-    }
-    getWatchedFiles() {
-        return Array.from(this.watchedFiles);
-    }
-    getOptions() {
-        return { ...this.options };
-    }
-}
-exports.FileWatcher = FileWatcher;