neex 0.3.2 → 0.3.4

package/dist/project-manager.js

@@ -15,23 +15,13 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+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 };
 };
@@ -40,15 +30,19 @@ exports.ProjectManager = void 0;
 const child_process_1 = require("child_process");
 const path_1 = require("path");
 const fs_1 = require("fs");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
 const chokidar_1 = require("chokidar");
 const typescript_runner_js_1 = require("./typescript-runner.js");
-const child_process_2 = require("child_process");
 const logger_js_1 = __importDefault(require("./logger.js"));
 const net = __importStar(require("net"));
+const readline = __importStar(require("readline"));
 class ProjectManager {
     constructor() {
         this.server = null;
         this.watcher = null;
+        this.buildWatcher = null;
+        this.isRestarting = false;
         this.tsRunner = new typescript_runner_js_1.FastTypeScriptRunner();
     }
     async startDev(options) {
@@ -57,8 +51,12 @@ class ProjectManager {
             if (!(0, fs_1.existsSync)(entryPath)) {
                 throw new Error(`Entry file ${options.entry} not found`);
             }
-            logger_js_1.default.printLine(`Starting development server with ${this.tsRunner['compiler']} compiler...`, 'info');
-            await this.startServer(entryPath, options);
+            logger_js_1.default.printLine(`Starting development server with ${options.compiler === 'auto' ? 'esbuild' : options.compiler} compiler...`, 'info');
+            // Initialize cache if enabled
+            if (options.cache) {
+                this.ensureCacheDir();
+            }
+            await this.startDevServer(entryPath, options);
             this.setupFileWatcher(options);
             this.setupCleanup();
         }
@@ -70,22 +68,17 @@ class ProjectManager {
         try {
             logger_js_1.default.printLine('Building project...', 'info');
             const startTime = Date.now();
-            const compiler = options.compiler === 'auto' ? this.tsRunner['compiler'] : options.compiler;
-            const buildCommand = this.getBuildCommand(compiler, options);
-            const build = (0, child_process_1.spawn)('sh', ['-c', buildCommand], {
-                stdio: 'inherit'
-            });
-            build.on('close', (code) => {
-                if (code === 0) {
-                    const buildTime = Date.now() - startTime;
-                    logger_js_1.default.printLine(`Build completed successfully in ${buildTime}ms`, 'info');
-                    logger_js_1.default.printLine(`Output: ${options.outDir}`, 'info');
-                }
-                else {
-                    logger_js_1.default.printLine(`Build failed with code ${code}`, 'error');
-                    process.exit(code ?? 1);
-                }
-            });
+            // Create output directory if it doesn't exist
+            if (!(0, fs_1.existsSync)(options.outDir)) {
+                (0, fs_1.mkdirSync)(options.outDir, { recursive: true });
+            }
+            const compiler = options.compiler === 'auto' ? 'esbuild' : options.compiler;
+            if (options.watch) {
+                await this.startBuildWatch(compiler, options);
+            }
+            else {
+                await this.executeBuild(compiler, options, startTime);
+            }
         }
         catch (error) {
             this.handleError(error);
@@ -98,7 +91,14 @@ class ProjectManager {
             const entryPath = (0, path_1.resolve)(process.cwd(), outDir, entryFile);
             if (!(0, fs_1.existsSync)(entryPath)) {
                 logger_js_1.default.printLine('Build not found. Building project first...', 'warn');
-                await this.build({ outDir: 'dist', minify: false, sourcemap: false, watch: false, compiler: 'auto', target: 'ES2022' });
+                await this.build({
+                    outDir: options.outDir,
+                    minify: true,
+                    sourcemap: false,
+                    watch: false,
+                    compiler: 'esbuild',
+                    target: 'ES2022'
+                });
             }
             await this.startProductionServer(entryPath, options);
         }
@@ -106,60 +106,135 @@ class ProjectManager {
             this.handleError(error);
         }
     }
-    async findAvailablePort(startPort = 8000) {
-        return new Promise((resolve, reject) => {
+    async isPortAvailable(port) {
+        return new Promise((resolve) => {
             const server = net.createServer();
             server.unref();
-            const tryPort = (port) => {
-                if (port > 8003) {
-                    server.close();
-                    logger_js_1.default.printLine('All default ports (8000-8003) are in use.', 'error');
-                    logger_js_1.default.printLine('Please specify a custom port in your .env file:', 'info');
-                    logger_js_1.default.printLine('PORT=your_custom_port', 'info');
-                    process.exit(1);
-                }
-                server.once('error', (err) => {
-                    if (err.code === 'EADDRINUSE') {
-                        tryPort(port + 1);
+            server.on('error', () => {
+                resolve(false);
+            });
+            server.on('listening', () => {
+                server.close(() => {
+                    resolve(true);
+                });
+            });
+            server.listen(port);
+        });
+    }
+    async promptForPort() {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        return new Promise((resolve) => {
+            logger_js_1.default.printLine('', 'info');
+            logger_js_1.default.printLine('All default ports are in use.', 'warn');
+            logger_js_1.default.printLine('You can either:', 'info');
+            logger_js_1.default.printLine('  1. Set PORT in your .env file: PORT=your_custom_port', 'info');
+            logger_js_1.default.printLine('  2. Use -p flag: neex dev src/server.ts -p your_custom_port', 'info');
+            logger_js_1.default.printLine('  3. Enter a custom port now', 'info');
+            logger_js_1.default.printLine('', 'info');
+            const askForPort = () => {
+                rl.question(chalk_1.default.cyan('Enter a custom port (or press Ctrl+C to exit): '), async (answer) => {
+                    const port = parseInt(answer.trim());
+                    if (isNaN(port) || port < 1 || port > 65535) {
+                        logger_js_1.default.printLine('Please enter a valid port number (1-65535)', 'error');
+                        askForPort();
+                        return;
                     }
-                    else {
-                        reject(err);
+                    if (port < 1024) {
+                        logger_js_1.default.printLine('Warning: Ports below 1024 may require administrator privileges', 'warn');
                     }
+                    const available = await this.isPortAvailable(port);
+                    if (!available) {
+                        logger_js_1.default.printLine(`Port ${port} is already in use. Try another port.`, 'error');
+                        askForPort();
+                        return;
+                    }
+                    rl.close();
+                    resolve(port);
                 });
-                server.once('listening', () => {
-                    server.close(() => {
-                        resolve(port);
-                    });
-                });
-                server.listen(port);
             };
-            tryPort(startPort);
+            askForPort();
         });
     }
-    async startServer(entryPath, options) {
+    async findAvailablePort(requestedPort = 8000, maxTries = 10) {
+        const isRequestedPortAvailable = await this.isPortAvailable(requestedPort);
+        if (isRequestedPortAvailable) {
+            return requestedPort;
+        }
+        logger_js_1.default.printLine(`Port ${requestedPort} is already in use. Searching for available port...`, 'warn');
+        for (let i = 1; i <= maxTries; i++) {
+            const tryPort = requestedPort + i;
+            logger_js_1.default.printLine(`Checking port ${tryPort}...`, 'info');
+            const available = await this.isPortAvailable(tryPort);
+            if (available) {
+                logger_js_1.default.printLine(`✓ Found available port: ${tryPort}`, 'info');
+                return tryPort;
+            }
+            else {
+                logger_js_1.default.printLine(`✗ Port ${tryPort} is in use`, 'warn');
+            }
+            if (i < maxTries) {
+                await new Promise(resolve => setTimeout(resolve, 50));
+            }
+        }
+        logger_js_1.default.printLine(`All ports from ${requestedPort} to ${requestedPort + maxTries} are in use.`, 'warn');
+        return await this.promptForPort();
+    }
+    getRequestedPort(options) {
+        let requestedPort;
+        if (options.port && options.port !== '') {
+            requestedPort = options.port;
+            logger_js_1.default.printLine(`Using port from command line: ${requestedPort}`, 'info');
+        }
+        else if (process.env.PORT) {
+            requestedPort = process.env.PORT;
+            logger_js_1.default.printLine(`Using port from .env file: ${requestedPort}`, 'info');
+        }
+        else {
+            requestedPort = '8000';
+            logger_js_1.default.printLine(`Using default port: ${requestedPort}`, 'info');
+        }
+        const port = parseInt(requestedPort);
+        if (isNaN(port) || port < 1 || port > 65535) {
+            logger_js_1.default.printLine(`Invalid port number: ${requestedPort}. Using default port 8000.`, 'warn');
+            return 8000;
+        }
+        return port;
+    }
+    async startDevServer(entryPath, options) {
         if (this.server) {
             this.server.kill('SIGTERM');
-            await new Promise(resolve => setTimeout(resolve, 100));
+            await new Promise(resolve => setTimeout(resolve, 200));
         }
         try {
             const startTime = Date.now();
-            let executablePath = entryPath;
-            if (entryPath.endsWith('.ts')) {
-                executablePath = await this.tsRunner.compile(entryPath);
-                const compileTime = Date.now() - startTime;
-                logger_js_1.default.printLine(`Compiled in ${compileTime}ms`, 'info');
-            }
-            else {
-                logger_js_1.default.printLine('Using JavaScript file directly', 'info');
+            const compiler = options.compiler === 'auto' ? 'esbuild' : options.compiler;
+            // Build the project first
+            const buildOptions = {
+                outDir: '.neex/dev',
+                minify: false,
+                sourcemap: true,
+                watch: false,
+                compiler,
+                target: 'ES2022'
+            };
+            await this.executeBuild(compiler, buildOptions, startTime, true);
+            // Get the built file path
+            const entryName = entryPath.split('/').pop()?.replace('.ts', '.js') || 'server.js';
+            const builtPath = (0, path_1.resolve)(process.cwd(), '.neex/dev', entryName);
+            if (!(0, fs_1.existsSync)(builtPath)) {
+                throw new Error(`Built file not found: ${builtPath}`);
             }
             const nodeArgs = [];
             if (options.inspect)
                 nodeArgs.push('--inspect');
             if (options.inspectBrk)
                 nodeArgs.push('--inspect-brk');
-            const requestedPort = options.port || process.env.PORT || '8000';
-            const port = await this.findAvailablePort(parseInt(requestedPort || '8000'));
-            this.server = (0, child_process_1.spawn)('node', [...nodeArgs, executablePath], {
+            const requestedPort = this.getRequestedPort(options);
+            const port = await this.findAvailablePort(requestedPort);
+            this.server = (0, child_process_1.spawn)('node', [...nodeArgs, builtPath], {
                 stdio: 'inherit',
                 env: {
                     ...process.env,
@@ -176,12 +251,86 @@ class ProjectManager {
                     logger_js_1.default.printLine(`Server crashed with code ${code}`, 'error');
                 }
             });
-            logger_js_1.default.printLine(`Server started on port ${port}`, 'info');
+            const totalTime = Date.now() - startTime;
+            logger_js_1.default.printLine(`${chalk_1.default.green(figures_1.default.tick)} Server started successfully on port ${chalk_1.default.bold.cyan(port)} (${totalTime}ms)`, 'info');
+            logger_js_1.default.printLine(`${chalk_1.default.gray('Local:')}   http://localhost:${port}`, 'info');
         }
         catch (error) {
             this.handleError(error);
         }
     }
+    async executeBuild(compiler, options, startTime, isDev = false) {
+        const buildCommand = this.getBuildCommand(compiler, options, isDev);
+        return new Promise((resolve, reject) => {
+            const build = (0, child_process_1.spawn)('sh', ['-c', buildCommand], {
+                stdio: isDev ? 'pipe' : 'inherit'
+            });
+            build.on('close', (code) => {
+                if (code === 0) {
+                    const buildTime = Date.now() - startTime;
+                    if (!isDev) {
+                        logger_js_1.default.printLine(`Build completed successfully in ${buildTime}ms`, 'info');
+                        logger_js_1.default.printLine(`Output: ${options.outDir}`, 'info');
+                    }
+                    resolve();
+                }
+                else {
+                    const error = new Error(`Build failed with code ${code}`);
+                    if (!isDev) {
+                        logger_js_1.default.printLine(`Build failed with code ${code}`, 'error');
+                    }
+                    reject(error);
+                }
+            });
+            build.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    async startBuildWatch(compiler, options) {
+        logger_js_1.default.printLine('Starting build in watch mode...', 'info');
+        this.buildWatcher = (0, chokidar_1.watch)(['src/**/*'], {
+            ignored: [
+                '**/*.map',
+                '**/*.d.ts',
+                '**/node_modules/**'
+            ],
+            persistent: true,
+            ignoreInitial: false,
+            awaitWriteFinish: {
+                stabilityThreshold: 200,
+                pollInterval: 50
+            }
+        });
+        let buildTimer = null;
+        let isBuilding = false;
+        const handleBuild = async () => {
+            if (isBuilding)
+                return;
+            if (buildTimer) {
+                clearTimeout(buildTimer);
+            }
+            buildTimer = setTimeout(async () => {
+                isBuilding = true;
+                try {
+                    const startTime = Date.now();
+                    await this.executeBuild(compiler, options, startTime);
+                }
+                catch (error) {
+                    logger_js_1.default.printLine('Build failed', 'error');
+                }
+                finally {
+                    isBuilding = false;
+                }
+            }, 300);
+        };
+        this.buildWatcher
+            .on('change', handleBuild)
+            .on('add', handleBuild)
+            .on('unlink', handleBuild);
+        // Initial build
+        await handleBuild();
+    }
     setupFileWatcher(options) {
         this.watcher = (0, chokidar_1.watch)(options.watch, {
             ignored: [
@@ -189,7 +338,8 @@ class ProjectManager {
                 /(^|[\/\\])\../,
                 '**/*.map',
                 '**/*.d.ts',
-                '**/node_modules/**'
+                '**/node_modules/**',
+                '**/.neex/**'
             ],
             persistent: true,
             ignoreInitial: true,
@@ -199,25 +349,33 @@ class ProjectManager {
             }
         });
         let restartTimer = null;
-        let isRestarting = false;
         const handleFileChange = (path, event) => {
             const ext = path.split('.').pop()?.toLowerCase();
             if (!ext || !options.ext.includes(ext)) {
                 return;
             }
+            if (this.isRestarting) {
+                return;
+            }
             if (restartTimer) {
                 clearTimeout(restartTimer);
             }
-            isRestarting = true;
-            restartTimer = setTimeout(() => {
+            this.isRestarting = true;
+            restartTimer = setTimeout(async () => {
                 if (options.clear) {
                     process.stdout.write('\x1Bc');
                 }
                 logger_js_1.default.printLine(`${event}: ${path}`, 'info');
                 logger_js_1.default.printLine('Restarting server...', 'info');
-                this.startServer((0, path_1.resolve)(process.cwd(), options.entry), options).then(() => {
-                    isRestarting = false;
-                });
+                try {
+                    await this.startDevServer((0, path_1.resolve)(process.cwd(), options.entry), options);
+                }
+                catch (error) {
+                    logger_js_1.default.printLine('Failed to restart server', 'error');
+                }
+                finally {
+                    this.isRestarting = false;
+                }
             }, parseInt(options.delay));
         };
         this.watcher
@@ -227,23 +385,50 @@ class ProjectManager {
     }
     setupCleanup() {
         const handleSignal = (signal) => {
+            logger_js_1.default.printLine('\nShutting down server...', 'info');
             if (this.server) {
                 this.server.kill('SIGTERM');
             }
             if (this.watcher) {
                 this.watcher.close();
             }
+            if (this.buildWatcher) {
+                this.buildWatcher.close();
+            }
+            // Clean up dev build directory
+            const devBuildDir = (0, path_1.resolve)(process.cwd(), '.neex/dev');
+            if ((0, fs_1.existsSync)(devBuildDir)) {
+                try {
+                    (0, fs_1.rmSync)(devBuildDir, { recursive: true, force: true });
+                }
+                catch (error) {
+                    // Ignore cleanup errors
+                }
+            }
+            process.exit(0);
         };
         process.on('SIGINT', () => handleSignal('SIGINT'));
         process.on('SIGTERM', () => handleSignal('SIGTERM'));
         process.on('SIGQUIT', () => handleSignal('SIGQUIT'));
     }
-    getBuildCommand(compiler, options) {
+    getBuildCommand(compiler, options, isDev = false) {
+        const srcPattern = isDev ? 'src/**/*.ts' : 'src/**/*.ts';
         switch (compiler) {
             case 'swc':
                 return `npx swc src -d ${options.outDir} --config-file .swcrc`;
             case 'esbuild':
-                return `npx esbuild src/**/*.ts --outdir=${options.outDir} --platform=node --target=node18 --format=cjs${options.sourcemap ? ' --sourcemap' : ''}${options.minify ? ' --minify' : ''}`;
+                const esbuildFlags = [
+                    `--outdir=${options.outDir}`,
+                    '--platform=node',
+                    `--target=${options.target.toLowerCase()}`,
+                    '--format=cjs',
+                    options.sourcemap ? '--sourcemap' : '',
+                    options.minify && !isDev ? '--minify' : '',
+                    '--bundle',
+                    '--external:node_modules/*'
+                ].filter(Boolean).join(' ');
+                return `npx esbuild ${srcPattern} ${esbuildFlags}`;
+            case 'tsc':
             default:
                 return `npx tsc --outDir ${options.outDir}${options.sourcemap ? ' --sourceMap' : ''}`;
         }
@@ -255,8 +440,8 @@ class ProjectManager {
             nodeArgs.push('--inspect');
         if (options.maxMemory)
             nodeArgs.push(`--max-old-space-size=${options.maxMemory.replace('M', '')}`);
-        const requestedPort = options.port || process.env.PORT || '8000';
-        const port = await this.findAvailablePort(parseInt(requestedPort));
+        const requestedPort = this.getRequestedPort(options);
+        const port = await this.findAvailablePort(requestedPort);
         let serverCommand = 'node';
         let serverArgs = [...nodeArgs, entryPath];
         if (options.cluster) {
@@ -275,7 +460,14 @@ class ProjectManager {
             logger_js_1.default.printLine(`Server error: ${err.message}`, 'error');
             process.exit(1);
         });
-        logger_js_1.default.printLine(`Production server started on port ${port}`, 'info');
+        logger_js_1.default.printLine(`${chalk_1.default.green(figures_1.default.tick)} Production server started successfully on port ${chalk_1.default.bold.cyan(port)}`, 'info');
+        logger_js_1.default.printLine(`${chalk_1.default.gray('Local:')}   http://localhost:${port}`, 'info');
+    }
+    ensureCacheDir() {
+        const cacheDir = this.getCachePath();
+        if (!(0, fs_1.existsSync)(cacheDir)) {
+            (0, fs_1.mkdirSync)(cacheDir, { recursive: true });
+        }
     }
     handleError(error) {
         if (error instanceof Error) {
@@ -286,11 +478,74 @@ class ProjectManager {
         }
         process.exit(1);
     }
+    calculateDirectorySize(dirPath) {
+        let totalSize = 0;
+        try {
+            const files = (0, fs_1.readdirSync)(dirPath);
+            for (const file of files) {
+                const filePath = (0, path_1.join)(dirPath, file);
+                const stats = (0, fs_1.statSync)(filePath);
+                if (stats.isDirectory()) {
+                    totalSize += this.calculateDirectorySize(filePath);
+                }
+                else {
+                    totalSize += stats.size;
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors and return 0
+        }
+        return totalSize;
+    }
+    formatFileSize(bytes) {
+        if (bytes === 0)
+            return '0B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + sizes[i];
+    }
+    countFiles(dirPath) {
+        let count = 0;
+        try {
+            const files = (0, fs_1.readdirSync)(dirPath);
+            for (const file of files) {
+                const filePath = (0, path_1.join)(dirPath, file);
+                const stats = (0, fs_1.statSync)(filePath);
+                if (stats.isDirectory()) {
+                    count += this.countFiles(filePath);
+                }
+                else {
+                    count++;
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors
+        }
+        return count;
+    }
+    // Public methods for cache management
     clearCache() {
+        const cacheDir = this.getCachePath();
+        if ((0, fs_1.existsSync)(cacheDir)) {
+            try {
+                (0, fs_1.rmSync)(cacheDir, { recursive: true, force: true });
+                logger_js_1.default.printLine('Cache cleared successfully', 'info');
+            }
+            catch (error) {
+                logger_js_1.default.printLine('Failed to clear cache', 'error');
+            }
+        }
+        else {
+            logger_js_1.default.printLine('Cache directory does not exist', 'warn');
+        }
+        // Also clear TypeScript runner cache
         this.tsRunner.clearCache();
     }
     getCacheStats() {
-        const cacheDir = (0, path_1.join)(process.cwd(), '.neex', 'cache');
+        const cacheDir = this.getCachePath();
         if (!(0, fs_1.existsSync)(cacheDir)) {
             return {
                 size: '0B',
@@ -298,25 +553,38 @@ class ProjectManager {
                 lastUpdated: 'Never'
             };
         }
-        const size = (0, child_process_2.execSync)(`du -sh ${cacheDir}`, { encoding: 'utf8' }).trim().split('\t')[0];
-        const files = (0, child_process_2.execSync)(`find ${cacheDir} -type f | wc -l`, { encoding: 'utf8' }).trim();
-        const lastUpdated = (0, child_process_2.execSync)(`stat -f "%Sm" ${cacheDir}`, { encoding: 'utf8' }).trim();
-        return {
-            size,
-            files: parseInt(files),
-            lastUpdated
-        };
+        try {
+            const totalSize = this.calculateDirectorySize(cacheDir);
+            const fileCount = this.countFiles(cacheDir);
+            const stats = (0, fs_1.statSync)(cacheDir);
+            return {
+                size: this.formatFileSize(totalSize),
+                files: fileCount,
+                lastUpdated: stats.mtime.toISOString()
+            };
+        }
+        catch (error) {
+            return {
+                size: '0B',
+                files: 0,
+                lastUpdated: 'Error reading cache'
+            };
+        }
     }
     getCachePath() {
         return (0, path_1.join)(process.cwd(), '.neex', 'cache');
     }
     cleanup(signal) {
+        logger_js_1.default.printLine('\nShutting down server...', 'info');
         if (this.server) {
             this.server.kill('SIGTERM');
         }
         if (this.watcher) {
             this.watcher.close();
         }
+        if (this.buildWatcher) {
+            this.buildWatcher.close();
+        }
     }
 }
 exports.ProjectManager = ProjectManager;