neex 0.6.45 → 0.6.46

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

@@ -1,256 +1,60 @@
 "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.addStartCommands = void 0;
 const start_manager_js_1 = require("../start-manager.js");
-const chalk_1 = __importDefault(require("chalk"));
-const figures_1 = __importDefault(require("figures"));
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs/promises"));
-// Helper function to check if file exists
-async function fileExists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-// Helper function to determine the best command to start the application
-async function getStartCommand(filePath, showInfo) {
-    const ext = path.extname(filePath).toLowerCase();
-    const absolutePath = path.resolve(process.cwd(), filePath);
-    const fileName = path.basename(filePath, ext);
-    // Check if file exists
-    if (!(await fileExists(absolutePath))) {
-        throw new Error(`File not found: ${filePath}`);
-    }
-    if (showInfo) {
-        console.log(chalk_1.default.blue(`${figures_1.default.info} neex start: Analyzing ${chalk_1.default.cyan(path.basename(filePath))}`));
-    }
-    switch (ext) {
-        case '.js':
-        case '.mjs':
-        case '.cjs':
-            if (showInfo) {
-                console.log(chalk_1.default.green(`${figures_1.default.tick} neex start: JavaScript detected, using Node.js runtime`));
-            }
-            return {
-                command: `node ${filePath}`,
-                runtime: 'Node.js',
-                processName: fileName
-            };
-        case '.ts':
-        case '.mts':
-        case '.cts':
-            if (showInfo) {
-                console.log(chalk_1.default.yellow(`${figures_1.default.warning} neex start: TypeScript detected, consider building first`));
-                console.log(chalk_1.default.yellow(`${figures_1.default.pointer} Tip: Run 'neex build ${filePath}' first, then start the built .js file`));
-            }
-            return {
-                command: `npx ts-node ${filePath}`,
-                runtime: 'TypeScript (ts-node)',
-                processName: fileName
-            };
-        default:
-            if (showInfo) {
-                console.log(chalk_1.default.yellow(`${figures_1.default.warning} neex start: Unknown file type, using Node.js`));
-            }
-            return {
-                command: `node ${filePath}`,
-                runtime: 'Node.js',
-                processName: fileName
-            };
-    }
-}
+const logger_manager_js_1 = require("../logger-manager.js");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 function addStartCommands(program) {
-    let startManager = null;
-    // Start command - run applications in production mode
-    program
-        .command('start <file>') // Made file mandatory
-        .alias('s')
-        .description('Start JavaScript/TypeScript applications in production mode')
-        .option('-c, --no-color', 'Disable colored output')
-        .option('-t, --no-timing', 'Hide timing information')
-        .option('-p, --no-prefix', 'Hide command prefix')
-        .option('-o, --no-output', 'Hide command output')
-        .option('-m, --minimal', 'Use minimal output format')
-        .option('-w, --watch', 'Watch for changes and restart (production hot-reload)')
-        .option('-i, --ignore <patterns...>', 'Patterns to ignore when watching')
-        .option('-e, --ext <extensions...>', 'File extensions to watch (default: js,mjs,json)')
-        .option('-d, --delay <ms>', 'Delay before restart in milliseconds', parseInt)
-        .option('--max-restarts <number>', 'Maximum number of restarts', parseInt)
-        .option('--restart-delay <ms>', 'Delay between restarts in milliseconds', parseInt)
-        .option('--verbose', 'Verbose output')
-        .option('--info', 'Show detailed information during startup')
-        .option('--signal <signal>', 'Signal to send to processes on restart', 'SIGTERM')
-        .option('--env <env>', 'Environment mode', 'production')
-        .option('--cluster', 'Enable cluster mode (spawn multiple processes)')
-        .option('--cluster-instances <number>', 'Number of cluster instances', parseInt)
-        .option('--memory-limit <mb>', 'Memory limit in MB', parseInt)
-        .option('--cpu-limit <percent>', 'CPU limit percentage', parseInt)
-        .action(async (file, options) => {
-        try {
-            const showInfo = options.info || false;
-            if (showInfo) {
-                console.log(chalk_1.default.blue(`${figures_1.default.info} neex start: Starting production application server...`));
-                console.log(chalk_1.default.blue(`${figures_1.default.info} neex start: Target file: ${chalk_1.default.cyan(file)}`));
-            }
-            // Validate file parameter
-            if (!file || file.trim() === '') {
-                console.error(chalk_1.default.red(`${figures_1.default.cross} neex start: Error - No file specified!`));
-                console.error(chalk_1.default.yellow(`${figures_1.default.pointer} Usage: neex start <file>`));
-                console.error(chalk_1.default.yellow(`${figures_1.default.pointer} Example: neex start dist/server.js`));
-                process.exit(1);
+    let manager = null;
+    const startCommand = program
+        .command('start [entry]')
+        .description('Start a production-ready application')
+        .option('-n, --name <name>', 'Application name')
+        .option('-w, --watch', 'Watch for file changes and restart the application', false)
+        .option('--quiet', 'Suppress all output', false)
+        .option('--color', 'Force color output', true)
+        .option('--verbose', 'Enable verbose logging', false)
+        .option('--node-args <args>', 'Arguments to pass to the node process', (value) => value.split(' '), [])
+        .action(async (entry, options) => {
+        let entryPoint = entry;
+        if (!entryPoint) {
+            const defaultPath = path_1.default.join(process.cwd(), 'dist', 'index.js');
+            if (fs_1.default.existsSync(defaultPath)) {
+                entryPoint = defaultPath;
             }
-            // Get the start command configuration
-            let startConfig;
-            try {
-                startConfig = await getStartCommand(file, showInfo);
-            }
-            catch (error) {
-                console.error(chalk_1.default.red(`${figures_1.default.cross} neex start: ${error instanceof Error ? error.message : 'Unknown error occurred'}`));
+            else {
+                logger_manager_js_1.loggerManager.printLine('Entry file not found. Please specify an entry file or build the project first.', 'error');
                 process.exit(1);
             }
-            // Setup watch configuration if enabled
-            const watchPaths = options.watch ? [path.dirname(file)] : [];
-            const ignorePatterns = options.ignore || [
-                'node_modules/**',
-                '.git/**',
-                '*.log',
-                'src/**',
-                'test/**',
-                'tests/**',
-                'coverage/**',
-                '.nyc_output/**',
-                '*.tmp',
-                '*.temp',
-                '.DS_Store',
-                'Thumbs.db'
-            ];
-            const extensions = options.ext || ['js', 'mjs', 'json'];
-            // Ensure environment is always set to production unless explicitly overridden
-            const environment = options.env === 'development' ? options.env : 'production';
-            // Log configuration only if --info flag is set
-            if (showInfo) {
-                console.log(chalk_1.default.blue(`${figures_1.default.info} neex start: Configuration:`));
-                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Target: ${chalk_1.default.cyan(file)}`));
-                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Runtime: ${chalk_1.default.cyan(startConfig.runtime)}`));
-                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Process name: ${chalk_1.default.cyan(startConfig.processName)}`));
-                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Environment: ${chalk_1.default.cyan(environment)}`));
-                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Watch mode: ${chalk_1.default.cyan(options.watch ? 'Yes' : 'No')}`));
-                console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Cluster mode: ${chalk_1.default.cyan(options.cluster ? 'Yes' : 'No')}`));
-                if (options.cluster) {
-                    console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Cluster instances: ${chalk_1.default.cyan(options.clusterInstances || 'auto')}`));
-                }
-                if (options.watch) {
-                    console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Watch paths: ${chalk_1.default.cyan(watchPaths.join(', '))}`));
-                    console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Extensions: ${chalk_1.default.cyan(extensions.join(', '))}`));
-                    console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Restart delay: ${chalk_1.default.cyan(options.delay || 1000)}ms`));
-                }
-                if (options.maxRestarts) {
-                    console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Max restarts: ${chalk_1.default.cyan(options.maxRestarts)}`));
-                }
-                if (options.memoryLimit) {
-                    console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} Memory limit: ${chalk_1.default.cyan(options.memoryLimit)}MB`));
-                }
-                if (options.cpuLimit) {
-                    console.log(chalk_1.default.blue(`  ${figures_1.default.arrowRight} CPU limit: ${chalk_1.default.cyan(options.cpuLimit)}%`));
-                }
-                if (options.verbose) {
-                    console.log(chalk_1.default.blue(`${figures_1.default.info} neex start: Verbose mode enabled - showing detailed logs`));
-                }
-                console.log(chalk_1.default.green(`${figures_1.default.tick} neex start: Starting production application server...`));
-                console.log(chalk_1.default.green(`${figures_1.default.tick} neex start: Launching ${chalk_1.default.cyan(startConfig.processName)} in ${chalk_1.default.cyan(environment)} mode...`));
-                console.log(chalk_1.default.blue(`${figures_1.default.info} neex start: Press Ctrl+C to stop the application server`));
-                console.log(chalk_1.default.gray(`${'='.repeat(60)}`));
-            }
-            // Create StartManager instance
-            startManager = new start_manager_js_1.StartManager({
-                runnerName: 'neex start',
-                targetFile: file,
-                command: startConfig.command,
-                processName: startConfig.processName,
-                runtime: startConfig.runtime,
-                environment: environment,
-                parallel: false,
-                color: options.color,
-                showTiming: options.timing,
-                prefix: options.prefix,
-                printOutput: options.output,
-                minimalOutput: options.minimal,
-                watch: options.watch,
-                watchPaths: watchPaths,
-                ignore: ignorePatterns,
-                ext: extensions,
-                delay: options.delay || 1000,
-                maxRestarts: options.maxRestarts,
-                restartDelay: options.restartDelay || 3000,
-                verbose: options.verbose,
-                showInfo: showInfo,
-                signal: options.signal,
-                cluster: options.cluster,
-                clusterInstances: options.clusterInstances,
-                memoryLimit: options.memoryLimit,
-                cpuLimit: options.cpuLimit,
-                groupOutput: false,
-                isServerMode: true,
-                stopOnError: false
-            });
-            // Start the application server
-            await startManager.start();
+        }
+        const startOptions = {
+            entry: entryPoint,
+            name: options.name,
+            watch: options.watch,
+            quiet: options.quiet,
+            color: options.color,
+            verbose: options.verbose,
+            nodeArgs: options.nodeArgs,
+        };
+        manager = new start_manager_js_1.StartManager(startOptions);
+        try {
+            await manager.start();
         }
         catch (error) {
-            console.error(chalk_1.default.red(`${figures_1.default.cross} neex start: Fatal error occurred`));
-            if (error instanceof Error) {
-                console.error(chalk_1.default.red(`${figures_1.default.cross} Details: ${error.message}`));
-                if (options.verbose && error.stack) {
-                    console.error(chalk_1.default.gray(`Stack trace:\n${error.stack}`));
-                }
-            }
-            else {
-                console.error(chalk_1.default.red(`${figures_1.default.cross} Unknown error occurred`));
-            }
-            console.error(chalk_1.default.yellow(`${figures_1.default.pointer} Try running with --verbose flag for more details`));
+            logger_manager_js_1.loggerManager.printLine(error.message, 'error');
             process.exit(1);
         }
     });
-    // Return cleanup function for start manager
     return {
-        getStartManager: () => startManager,
-        cleanupStart: () => {
-            if (startManager && startManager.isActive()) {
-                console.log(chalk_1.default.blue(`${figures_1.default.info} neex start: Stopping application server...`));
-                startManager.stop();
-                console.log(chalk_1.default.green(`${figures_1.default.tick} neex start: Application server stopped successfully`));
+        cleanupStart: async () => {
+            if (manager) {
+                await manager.stop();
             }
-        }
+        },
     };
 }
 exports.addStartCommands = addStartCommands;

package/dist/src/dev-manager.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevManager = void 0;
+// src/dev-manager.ts - Development server manager with hot reloading
+const child_process_1 = require("child_process");
+const chokidar_1 = require("chokidar");
+const logger_manager_js_1 = require("./logger-manager.js");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const lodash_1 = require("lodash");
+class DevManager {
+    constructor(options) {
+        this.process = null;
+        this.watcher = null;
+        this.isRestarting = false;
+        this.restartCount = 0;
+        this.startTime = null;
+        this.options = options;
+        this.debouncedRestart = (0, lodash_1.debounce)(this.restart.bind(this), options.delay);
+    }
+    loadEnvFile() {
+        if (this.options.envFile && fs_1.default.existsSync(this.options.envFile)) {
+            try {
+                const envContent = fs_1.default.readFileSync(this.options.envFile, 'utf8');
+                const lines = envContent.split('\n');
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (trimmed && !trimmed.startsWith('#')) {
+                        const [key, ...values] = trimmed.split('=');
+                        if (key && values.length > 0) {
+                            process.env[key.trim()] = values.join('=').trim();
+                        }
+                    }
+                }
+                if (this.options.verbose) {
+                    logger_manager_js_1.loggerManager.printLine(`Loaded environment variables from ${this.options.envFile}`, 'info');
+                }
+            }
+            catch (error) {
+                logger_manager_js_1.loggerManager.printLine(`Failed to load environment file ${this.options.envFile}: ${error.message}`, 'warn');
+            }
+        }
+    }
+    getExecuteCommand() {
+        if (this.options.execCommand) {
+            const parts = this.options.execCommand.split(' ');
+            return { command: parts[0], args: [...parts.slice(1), this.options.file] };
+        }
+        // Default to tsx for TypeScript files
+        const args = [this.options.file];
+        if (this.options.inspect) {
+            args.unshift('--inspect');
+        }
+        if (this.options.inspectBrk) {
+            args.unshift('--inspect-brk');
+        }
+        return { command: 'tsx', args };
+    }
+    clearConsole() {
+        if (this.options.clearConsole && process.stdout.isTTY) {
+            process.stdout.write('\x1b[2J\x1b[0f');
+        }
+    }
+    async startProcess() {
+        var _a, _b;
+        if (this.process) {
+            return;
+        }
+        this.loadEnvFile();
+        const { command, args } = this.getExecuteCommand();
+        if (this.options.verbose) {
+            logger_manager_js_1.loggerManager.printLine(`Executing: ${command} ${args.join(' ')}`, 'info');
+        }
+        this.process = (0, child_process_1.spawn)(command, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: false,
+            env: {
+                ...process.env,
+                NODE_ENV: process.env.NODE_ENV || 'development',
+                FORCE_COLOR: this.options.color ? '1' : '0'
+            },
+            detached: true
+        });
+        this.startTime = new Date();
+        this.restartCount++;
+        if (!this.options.quiet) {
+            const timestamp = new Date().toLocaleTimeString();
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.play)} Started ${chalk_1.default.cyan(this.options.file)} ${chalk_1.default.dim(`(${timestamp})`)}`, 'info');
+        }
+        (_a = this.process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+            if (!this.options.quiet) {
+                process.stdout.write(data);
+            }
+        });
+        (_b = this.process.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+            if (!this.options.quiet) {
+                process.stderr.write(data);
+            }
+        });
+        this.process.on('error', (error) => {
+            logger_manager_js_1.loggerManager.printLine(`Process error: ${error.message}`, 'error');
+        });
+        this.process.on('exit', (code, signal) => {
+            if (this.process) {
+                this.process = null;
+                if (!this.isRestarting) {
+                    if (code !== 0) {
+                        const duration = this.startTime ? Date.now() - this.startTime.getTime() : 0;
+                        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.red(figures_1.default.cross)} Process exited with code ${code} after ${duration}ms`, 'error');
+                    }
+                }
+            }
+        });
+    }
+    async stopProcess() {
+        if (!this.process) {
+            return;
+        }
+        return new Promise((resolve) => {
+            if (!this.process) {
+                resolve();
+                return;
+            }
+            const proc = this.process;
+            this.process = null;
+            const cleanup = () => {
+                if (!this.options.quiet) {
+                    logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.square)} Stopped process`, 'info');
+                }
+                resolve();
+            };
+            proc.on('exit', cleanup);
+            proc.on('error', cleanup);
+            try {
+                if (proc.pid) {
+                    // Kill process group
+                    process.kill(-proc.pid, 'SIGTERM');
+                    // Fallback after timeout
+                    setTimeout(() => {
+                        if (proc.pid && !proc.killed) {
+                            try {
+                                process.kill(-proc.pid, 'SIGKILL');
+                            }
+                            catch (e) {
+                                // Ignore
+                            }
+                        }
+                    }, 5000);
+                }
+            }
+            catch (error) {
+                // Process might already be dead
+                cleanup();
+            }
+        });
+    }
+    async restart() {
+        if (this.isRestarting) {
+            return;
+        }
+        this.isRestarting = true;
+        if (this.options.clearConsole) {
+            this.clearConsole();
+        }
+        if (!this.options.quiet) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.arrowRight)} Restarting due to changes...`, 'info');
+        }
+        await this.stopProcess();
+        await this.startProcess();
+        this.isRestarting = false;
+    }
+    setupWatcher() {
+        const watchPatterns = this.options.watch;
+        const ignored = [
+            '**/node_modules/**',
+            '**/.git/**',
+            '**/dist/**',
+            '**/build/**',
+            '**/*.log',
+            ...this.options.ignore.map(pattern => `**/${pattern}/**`)
+        ];
+        this.watcher = (0, chokidar_1.watch)(watchPatterns, {
+            ignored,
+            ignoreInitial: true,
+            followSymlinks: false,
+            usePolling: false,
+            atomic: 300
+        });
+        this.watcher.on('change', (filePath) => {
+            if (this.options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`File changed: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+            }
+            this.debouncedRestart();
+        });
+        this.watcher.on('add', (filePath) => {
+            if (this.options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`File added: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+            }
+            this.debouncedRestart();
+        });
+        this.watcher.on('unlink', (filePath) => {
+            if (this.options.verbose) {
+                logger_manager_js_1.loggerManager.printLine(`File removed: ${path_1.default.relative(process.cwd(), filePath)}`, 'info');
+            }
+            this.debouncedRestart();
+        });
+        this.watcher.on('error', (error) => {
+            logger_manager_js_1.loggerManager.printLine(`Watcher error: ${error.message}`, 'error');
+        });
+        if (this.options.verbose) {
+            logger_manager_js_1.loggerManager.printLine(`Watching: ${watchPatterns.join(', ')}`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`Ignoring: ${ignored.join(', ')}`, 'info');
+        }
+    }
+    async start() {
+        // Check if target file exists
+        if (!fs_1.default.existsSync(this.options.file)) {
+            throw new Error(`Target file not found: ${this.options.file}`);
+        }
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Starting development server...`, 'info');
+        // Show configuration in verbose mode
+        if (this.options.verbose) {
+            logger_manager_js_1.loggerManager.printLine(`Target file: ${this.options.file}`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`Watch patterns: ${this.options.watch.join(', ')}`, 'info');
+            logger_manager_js_1.loggerManager.printLine(`Restart delay: ${this.options.delay}ms`, 'info');
+        }
+        this.setupWatcher();
+        await this.startProcess();
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.green(figures_1.default.tick)} Development server started. Watching for changes...`, 'info');
+    }
+    async stop() {
+        logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.yellow(figures_1.default.warning)} Stopping development server...`, 'info');
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+        await this.stopProcess();
+        if (this.restartCount > 0) {
+            logger_manager_js_1.loggerManager.printLine(`${chalk_1.default.blue(figures_1.default.info)} Development server stopped after ${this.restartCount} restart(s)`, 'info');
+        }
+    }
+}
+exports.DevManager = DevManager;

package/dist/src/logger-manager.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerManager = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+exports.loggerManager = {
+    printLine: (message, level = "info") => {
+        const prefix = {
+            info: chalk_1.default.blue("i"),
+            warn: chalk_1.default.yellow("!"),
+            error: chalk_1.default.red("x"),
+        }[level];
+        console.log(`${prefix} ${message}`);
+    },
+};