xypriss 1.0.0 → 1.1.0

package/dist/esm/server/FastServer.js

@@ -0,0 +1,985 @@
+import express from 'express';
+import rateLimit from 'express-rate-limit';
+import { PluginManager } from './components/fastapi/PluginManager.js';
+import { PluginManager as PluginManager$1 } from '../plugins/plugin-manager.js';
+import { initializeLogger } from './utils/Logger.js';
+import { PortManager } from './utils/PortManager.js';
+import { Port } from './utils/forceClosePort.js';
+import { ConfigLoader } from './utils/ConfigLoader.js';
+import { DEFAULT_OPTIONS } from './const/default.js';
+import { CacheManager } from './components/fastapi/CacheManager.js';
+import { MiddlewareMethodsManager } from './components/fastapi/middlewares/MiddlewareMethodsManager.js';
+import { RequestProcessor } from './components/fastapi/RequestProcessor.js';
+import { RouteManager } from './components/fastapi/RouteManager.js';
+import { PerformanceManager } from './components/fastapi/PerformanceManager.js';
+import { MonitoringManager } from './components/fastapi/MonitoringManager.js';
+import { ClusterManagerComponent } from './components/fastapi/ClusterManagerComponent.js';
+import { FileWatcherManager } from './components/fastapi/FileWatcherManager.js';
+import { MiddlewareManager } from './components/fastapi/middlewares/middlewareManager.js';
+import { RedirectManager } from './components/fastapi/RedirectManager.js';
+import { ConsoleInterceptor } from './components/fastapi/console/ConsoleInterceptor.js';
+import { UltraFastRequestProcessor } from './components/fastapi/UltraFastRequestProcessor.js';
+import { createSafeJsonMiddleware } from '../middleware/safe-json-middleware.js';
+
+/**
+ * XyPrissJS - Ultra-Fast Server
+ * Main server class for XyPrissJS
+ */
+/**
+ * Ultra-Fast Express Server with Advanced Performance Optimization
+ */
+class XyPrissServer {
+    constructor(userOptions = {
+        server: {
+            enableMiddleware: true,
+        },
+    }) {
+        this.ready = false;
+        this.initPromise = Promise.resolve();
+        this.currentPort = 0; // Track the actual running port
+        // Load configuration from file system if available
+        const fileConfig = ConfigLoader.loadConfig();
+        // Merge configurations: defaults < file config < user options
+        this.options = this.mergeWithDefaults(userOptions, fileConfig);
+        // Initialize logger with user configuration
+        this.logger = initializeLogger(this.options.logging);
+        this.logger.startup("server", "Creating server...");
+        // Create Express app immediately
+        this.app = express();
+        // Expose logger on app object for debugging
+        this.app.logger = this.logger;
+        // Add start method immediately so it's available right away
+        this.addStartMethod();
+        // Add basic middleware methods immediately for developer-friendly API
+        this.addImmediateMiddlewareMethods();
+        // Initialize ultra-fast processor first (using legacy config for backward compatibility)
+        this.ultraFastProcessor = new UltraFastRequestProcessor({
+            cpuWorkers: this.options.performance?.workers?.cpu || 4,
+            ioWorkers: this.options.performance?.workers?.io || 2,
+            maxCacheSize: this.options.cache?.maxSize || 1000,
+            enablePrediction: true,
+            enableCompression: true,
+            maxConcurrentTasks: 100,
+        });
+        // Add safe JSON middleware to handle circular references
+        this.addSafeJsonMiddleware();
+        // Add ultra-fast middleware with type coercion
+        this.app.use((req, res, next) => {
+            const handler = this.ultraFastProcessor.middleware();
+            handler(req, res, next, "", {}).catch(next);
+        });
+        // Initialize other components asynchronously
+        this.initPromise = this.initializeComponentsAsync();
+        this.logger.debug("server", "Ultra-fast Express server created with optimized request processing");
+    }
+    async initializeComponentsAsync() {
+        // Initialize components in parallel for faster startup
+        await Promise.all([
+            this.initializeCache(),
+            this.initializePerformance(),
+            this.initializePlugins(),
+            this.initializeCluster(),
+            this.initializeFileWatcher(),
+        ]);
+        // Initialize components that depend on others
+        await this.initializeDependentComponents();
+        // Add routes and monitoring endpoints
+        this.routeManager.addMethods();
+        this.monitoringManager.addMonitoringEndpoints();
+        this.addConsoleInterceptionMethods();
+        this.ready = true;
+    }
+    async initializeCache() {
+        this.cacheManager = new CacheManager({
+            cache: this.options.cache,
+            performance: this.options.performance,
+            server: this.options.server,
+            env: this.options.env,
+        });
+        this.app.cache = this.cacheManager.getCache();
+        await this.cacheManager.initializeCache();
+    }
+    async initializePerformance() {
+        this.performanceManager = new PerformanceManager({
+            performance: this.options.performance,
+            server: this.options.server,
+            env: this.options.env,
+        }, {
+            app: this.app,
+            cacheManager: this.cacheManager,
+        });
+    }
+    async initializePlugins() {
+        this.pluginManager = new PluginManager({
+            app: this.app,
+            cacheManager: this.cacheManager,
+        });
+    }
+    async initializeCluster() {
+        // Only initialize cluster if it's explicitly configured and enabled
+        if (this.options.cluster?.enabled) {
+            this.clusterManager = new ClusterManagerComponent({
+                cluster: this.options.cluster,
+            }, {
+                app: this.app,
+            });
+        }
+    }
+    async initializeFileWatcher() {
+        this.fileWatcherManager = new FileWatcherManager({
+            fileWatcher: this.options.fileWatcher,
+        }, {
+            app: this.app,
+            clusterManager: this.clusterManager,
+        });
+    }
+    async initializeDependentComponents() {
+        // Initialize components that depend on others
+        this.requestProcessor = new RequestProcessor({
+            performanceProfiler: this.performanceManager.getPerformanceProfiler(),
+            executionPredictor: this.performanceManager.getExecutionPredictor(),
+            requestPreCompiler: this.performanceManager.getRequestPreCompiler(),
+            pluginEngine: this.pluginManager.getPluginEngine(),
+            cacheManager: this.cacheManager,
+        });
+        this.middlewareManager = new MiddlewareManager({
+            server: this.options.server,
+            security: this.options.security,
+            performance: this.options.performance,
+            middleware: this.options.middleware,
+        }, {
+            app: this.app,
+            cache: this.cacheManager.getCache(),
+            performanceProfiler: this.performanceManager.getPerformanceProfiler(),
+            executionPredictor: this.performanceManager.getExecutionPredictor(),
+            optimizationEnabled: this.performanceManager.isOptimizationEnabled(),
+            optimizationStats: this.performanceManager.getOptimizationStats(),
+            handleUltraFastPath: this.ultraFastProcessor
+                .middleware()
+                .bind(this.ultraFastProcessor),
+            handleFastPath: this.requestProcessor.handleFastPath.bind(this.requestProcessor),
+            handleStandardPath: this.requestProcessor.handleStandardPath.bind(this.requestProcessor),
+        });
+        // Initialize remaining components
+        this.middlewareMethodsManager = new MiddlewareMethodsManager({
+            app: this.app,
+            middlewareManager: this.middlewareManager,
+        });
+        // Add middleware methods to the app (this will upgrade the immediate methods)
+        this.middlewareMethodsManager.addMiddlewareMethods();
+        // Process any middleware that was queued during immediate usage
+        this.processQueuedMiddleware();
+        // Process any configs queued before middlewareManager was ready
+        const appAny = this.app;
+        if (appAny._immediateMiddlewareConfigs &&
+            Array.isArray(appAny._immediateMiddlewareConfigs)) {
+            appAny._immediateMiddlewareConfigs.forEach((config) => {
+                try {
+                    this.middlewareManager.applyImmediateMiddleware(config);
+                }
+                catch (error) {
+                    this.logger.warn("middleware", `Failed to apply queued middleware config: ${error}`);
+                }
+            });
+            appAny._immediateMiddlewareConfigs = [];
+        }
+        this.routeManager = new RouteManager({
+            app: this.app,
+            cacheManager: this.cacheManager,
+            middlewareManager: this.middlewareManager,
+            ultraFastOptimizer: this.performanceManager.getUltraFastOptimizer(),
+        });
+        this.monitoringManager = new MonitoringManager({
+            monitoring: this.options.monitoring,
+        }, {
+            app: this.app,
+            cacheManager: this.cacheManager,
+            performanceManager: this.performanceManager,
+        });
+        // Initialize request management middleware
+        this.initializeRequestManagement();
+        // Initialize server plugins
+        this.initializeServerPlugins();
+        this.redirectManager = new RedirectManager(this.logger);
+        this.consoleInterceptor = new ConsoleInterceptor(this.logger, this.options.logging);
+        if (this.options.logging?.consoleInterception?.enabled) {
+            this.consoleInterceptor.start();
+            this.logger.info("console", "Console interception system activated");
+        }
+        if (this.options.fileWatcher?.enabled) {
+            this.fileWatcherManager.addFileWatcherMonitoringEndpoints("/XyPriss");
+        }
+    }
+    /**
+     * Get the Express app instance (ready to use immediately)
+     */
+    getApp() {
+        return this.app;
+    }
+    /**
+     * Get the server plugin manager
+     */
+    getServerPluginManager() {
+        return this.serverPluginManager;
+    }
+    /**
+     * Wait for full initialization (cache, console interceptor, and all components)
+     */
+    async waitForReady() {
+        // Wait for cache initialization
+        await this.initPromise;
+        // Wait for console interceptor to be ready if enabled
+        if (this.options.logging?.consoleInterception?.enabled &&
+            this.consoleInterceptor) {
+            // Give console interceptor a moment to fully initialize
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        // Mark as ready
+        this.ready = true;
+        this.logger.debug("server", "All components initialized and ready");
+    }
+    /**
+     * Get the RequestPreCompiler instance for configuration
+     */
+    getRequestPreCompiler() {
+        return this.performanceManager.getRequestPreCompiler();
+    }
+    /**
+     * Get the ConsoleInterceptor instance for configuration
+     */
+    getConsoleInterceptor() {
+        return this.consoleInterceptor;
+    }
+    /**
+     * Merge user options with defaults and file config
+     */
+    mergeWithDefaults(userOptions, fileConfig = null) {
+        return {
+            ...DEFAULT_OPTIONS,
+            ...(fileConfig || {}),
+            ...userOptions,
+        };
+    }
+    /**
+     * Handle automatic port switching when port is in use
+     */
+    async handlePortSwitching(requestedPort, host = "localhost") {
+        const portManager = new PortManager(requestedPort, this.options.server?.autoPortSwitch);
+        const result = await portManager.findAvailablePort(host);
+        if (result.switched) {
+            this.logger.portSwitching("server", `🔄 Port ${requestedPort} was in use, switched to port ${result.port}`);
+            this.logger.portSwitching("server", `   Attempts: ${result.attempts}, Strategy: ${portManager.getConfig()?.strategy || "increment"}`);
+        }
+        if (!result.success) {
+            const maxAttempts = this.options.server?.autoPortSwitch?.maxAttempts || 10;
+            throw new Error(`Failed to find an available port after ${maxAttempts} attempts. ` +
+                `Original port: ${requestedPort}, Last attempted: ${result.port}`);
+        }
+        return result;
+    }
+    /**
+     * Start server with error handling and port switching
+     */
+    async startServerWithPortHandling(port, host, callback) {
+        try {
+            // Check port availability first when auto port switch is enabled
+            if (this.options.server?.autoPortSwitch?.enabled) {
+                const portManager = new PortManager(port, this.options.server?.autoPortSwitch);
+                const result = await portManager.findAvailablePort(host);
+                if (!result.success) {
+                    throw new Error(`Failed to find an available port after ${this.options.server?.autoPortSwitch?.maxAttempts ||
+                        10} attempts`);
+                }
+                if (result.switched) {
+                    this.logger.portSwitching("server", `🔄 Port ${port} was in use, switched to port ${result.port}`);
+                    port = result.port; // Use the switched port
+                }
+            }
+            else {
+                // console.log(`🔧 [DEBUG] Port switching NOT enabled`);
+            }
+            // Try to start server on the requested port
+            return new Promise((resolve, reject) => {
+                const server = this.app.listen(port, host, () => {
+                    this.currentPort = port; // Track the actual running port
+                    this.logger.info("server", `Server running on ${host}:${port}`);
+                    this.logger.debug("server", `State: ${this.ready ? "Ready" : "Initializing..."}`);
+                    if (callback)
+                        callback();
+                    resolve(server);
+                });
+                server.on("error", async (error) => {
+                    this.logger.debug("server", `Server error on port ${port}: ${error.code} - ${error.message}`);
+                    if (error.code === "EADDRINUSE") {
+                        // Port is in use, try auto-switching if enabled
+                        if (this.options.server?.autoPortSwitch?.enabled) {
+                            this.logger.info("server", `🔄 Port ${port} is in use, attempting auto port switch...`);
+                            try {
+                                const result = await this.handlePortSwitching(port, host);
+                                this.logger.info("server", `✅ Found available port: ${result.port}`);
+                                // Recursively try with the new port
+                                const newServer = await this.startServerWithPortHandling(result.port, host, callback);
+                                resolve(newServer);
+                            }
+                            catch (switchError) {
+                                this.logger.error("server", `❌ Port switching failed: ${switchError}`);
+                                reject(switchError);
+                            }
+                        }
+                        else {
+                            reject(new Error(`Failed to start server. Port ${port} is already in use. ` +
+                                `Enable autoPortSwitch in server config to automatically find an available port.`));
+                        }
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Add safe JSON middleware to handle circular references
+     */
+    addSafeJsonMiddleware() {
+        const safeJsonOptions = {
+            enabled: true,
+            maxDepth: 10,
+            logCircularRefs: this.options.env === "development",
+            truncateStrings: 1000,
+        };
+        this.app.use(createSafeJsonMiddleware(safeJsonOptions));
+        this.logger.debug("middleware", "Safe JSON middleware added for circular reference handling");
+    }
+    /**
+     * Apply middleware directly when MiddlewareManager is not available
+     * Fallback method for immediate middleware application
+     */
+    applyMiddlewareDirectly(config) {
+        // Apply rate limiting if configured
+        if (config?.rateLimit && config.rateLimit !== true) {
+            try {
+                // const rateLimit = require("express-rate-limit");
+                const rateLimitConfig = config.rateLimit;
+                const limiter = rateLimit({
+                    windowMs: rateLimitConfig.windowMs || 15 * 60 * 1000,
+                    max: rateLimitConfig.max || 100,
+                    message: rateLimitConfig.message ||
+                        "Too many requests from this IP, please try again later.",
+                    standardHeaders: rateLimitConfig.standardHeaders || true,
+                    legacyHeaders: rateLimitConfig.legacyHeaders || false,
+                    handler: rateLimitConfig.onLimitReached,
+                });
+                this.app.use(limiter);
+            }
+            catch (error) { }
+        }
+        // Apply CORS if configured
+        if (config?.cors && config.cors !== true) {
+            try {
+                const cors = require("cors");
+                const corsConfig = config.cors;
+                const corsOptions = {
+                    origin: corsConfig.origin || "*",
+                    methods: corsConfig.methods || [
+                        "GET",
+                        "POST",
+                        "PUT",
+                        "DELETE",
+                        "OPTIONS",
+                    ],
+                    allowedHeaders: corsConfig.allowedHeaders || [
+                        "Origin",
+                        "X-Requested-With",
+                        "Content-Type",
+                        "Accept",
+                        "Authorization",
+                    ],
+                    credentials: corsConfig.credentials !== false,
+                };
+                this.app.use(cors(corsOptions));
+            }
+            catch (error) { }
+        }
+        // Apply security headers if configured
+        if (config?.security && config.security !== true) {
+            try {
+                const helmet = require("helmet");
+                this.app.use(helmet());
+            }
+            catch (error) { }
+        }
+        // Apply compression if configured
+        if (config?.compression && config.compression !== true) {
+            try {
+                const compression = require("compression");
+                this.app.use(compression());
+            }
+            catch (error) {
+                this.logger.error("server", "Failed to apply compression:", error);
+            }
+        }
+    }
+    /**
+     * Add immediate middleware methods for developer-friendly API
+     * These work immediately without waiting for async initialization
+     */
+    addImmediateMiddlewareMethods() {
+        // Create a simple middleware queue for immediate use
+        const middlewareQueue = [];
+        // Add immediate middleware() method that implements MiddlewareAPIInterface
+        this.app.middleware = (config) => {
+            // Always queue or apply middleware depending on initialization state
+            if (config) {
+                if (this.middlewareManager) {
+                    // MiddlewareManager is ready, apply immediately
+                    // console.log("using builtin class");
+                    this.middlewareManager.applyImmediateMiddleware(config);
+                }
+                else {
+                    // console.log("using dirrect msg");
+                    // MiddlewareManager not ready, queue for later processing
+                    this.logger.debug("server", "MiddlewareManager not available, queuing for later processing");
+                    // Store config for later application
+                    if (!this.app._immediateMiddlewareConfigs) {
+                        this.app._immediateMiddlewareConfigs = [];
+                    }
+                    this.app._immediateMiddlewareConfigs.push(config);
+                    this.applyMiddlewareDirectly(config);
+                }
+            }
+            return {
+                register: (handler, options) => {
+                    // Store middleware for later registration
+                    middlewareQueue.push({ handler, options });
+                    // Also add it immediately to Express for basic functionality
+                    this.app.use(handler);
+                    return this; // Return for chaining
+                },
+                enable: (_id) => this,
+                disable: (_id) => this,
+                getInfo: () => [],
+                getStats: () => ({}),
+                unregister: (_id) => this,
+                getConfig: () => config || {},
+                clear: () => this,
+                optimize: async () => this,
+            };
+        };
+        // Store the queue for later processing
+        this.app._middlewareQueue = middlewareQueue;
+        // Add basic convenience methods
+        this.app.enableSecurity = (_options) => {
+            // Basic security headers immediately
+            this.app.use((_req, res, next) => {
+                res.setHeader("X-Content-Type-Options", "nosniff");
+                res.setHeader("X-Frame-Options", "DENY");
+                res.setHeader("X-XSS-Protection", "1; mode=block");
+                next();
+            });
+            return this.app;
+        };
+        this.app.enableCors = (_options) => {
+            // Basic CORS immediately
+            this.app.use((_req, res, next) => {
+                res.setHeader("Access-Control-Allow-Origin", "*");
+                res.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
+                res.setHeader("Access-Control-Allow-Headers", "Content-Type,Authorization");
+                next();
+            });
+            return this.app;
+        };
+        this.app.enableCompression = (_options) => {
+            // Basic compression will be added when full middleware manager is ready
+            return this.app;
+        };
+        this.app.enableRateLimit = (_options) => {
+            // Basic rate limiting will be added when full middleware manager is ready
+            return this.app;
+        };
+    }
+    /**
+     * Initialize request management middleware for timeouts, network quality, and concurrency control
+     */
+    initializeRequestManagement() {
+        const requestConfig = this.options.requestManagement;
+        if (!requestConfig)
+            return;
+        // Request timeout middleware
+        if (requestConfig.timeout?.enabled) {
+            this.app.use((req, res, next) => {
+                const route = req.route?.path || req.path;
+                const timeout = requestConfig.timeout?.routes?.[route] ||
+                    requestConfig.timeout?.defaultTimeout ||
+                    30000;
+                const timeoutId = setTimeout(() => {
+                    if (!res.headersSent) {
+                        if (requestConfig.timeout?.onTimeout) {
+                            requestConfig.timeout.onTimeout(req, res);
+                        }
+                        else {
+                            res.status(408).json({
+                                error: "Request timeout",
+                                timeout: timeout,
+                                path: req.path,
+                                ...(requestConfig.timeout
+                                    ?.includeStackTrace && {
+                                    stack: new Error().stack,
+                                }),
+                            });
+                        }
+                    }
+                }, timeout);
+                // Clear timeout when response finishes
+                res.on("finish", () => clearTimeout(timeoutId));
+                res.on("close", () => clearTimeout(timeoutId));
+                next();
+            });
+        }
+        // Concurrency control middleware
+        if (requestConfig.concurrency?.maxConcurrentRequests ||
+            requestConfig.concurrency?.maxPerIP) {
+            const activeRequests = new Map();
+            let totalActiveRequests = 0;
+            this.app.use((req, res, next) => {
+                const clientIP = req.ip || req.connection.remoteAddress;
+                const maxTotal = requestConfig.concurrency?.maxConcurrentRequests ||
+                    Infinity;
+                const maxPerIP = requestConfig.concurrency?.maxPerIP || Infinity;
+                const currentPerIP = activeRequests.get(clientIP) || 0;
+                // Check limits
+                if (totalActiveRequests >= maxTotal ||
+                    currentPerIP >= maxPerIP) {
+                    if (requestConfig.concurrency?.onQueueOverflow) {
+                        requestConfig.concurrency.onQueueOverflow(req, res);
+                    }
+                    else {
+                        res.status(429).json({
+                            error: "Too many concurrent requests",
+                            totalActive: totalActiveRequests,
+                            maxTotal,
+                            perIPActive: currentPerIP,
+                            maxPerIP,
+                        });
+                    }
+                    return;
+                }
+                // Track request
+                totalActiveRequests++;
+                activeRequests.set(clientIP, currentPerIP + 1);
+                // Clean up when request finishes
+                const cleanup = () => {
+                    totalActiveRequests--;
+                    const current = activeRequests.get(clientIP) || 0;
+                    if (current <= 1) {
+                        activeRequests.delete(clientIP);
+                    }
+                    else {
+                        activeRequests.set(clientIP, current - 1);
+                    }
+                };
+                res.on("finish", cleanup);
+                res.on("close", cleanup);
+                next();
+            });
+        }
+        this.logger.info("server", "Request management middleware initialized");
+    }
+    /**
+     * Initialize server plugins for optimization and maintenance
+     */
+    initializeServerPlugins() {
+        if (!this.options.plugins)
+            return;
+        this.serverPluginManager = new PluginManager$1(this.options.plugins);
+        this.serverPluginManager.initialize(this.app, this.logger);
+        // Expose plugin manager on app object
+        this.app.serverPluginManager = this.serverPluginManager;
+        this.app.getServerPluginManager = () => this.serverPluginManager;
+        // Setup plugin event handlers
+        this.serverPluginManager.on("route_optimized", (data) => {
+            this.logger.info("plugins", `Route optimized: ${data.routeKey}`);
+        });
+        this.serverPluginManager.on("maintenance_issue", (issue) => {
+            this.logger.warn("plugins", `Maintenance issue: ${issue.message}`);
+        });
+        this.serverPluginManager.on("critical_issue", (issue) => {
+            this.logger.error("plugins", `Critical issue detected: ${issue.message}`);
+        });
+        this.logger.info("server", "Server plugins initialized");
+    }
+    /**
+     * Process middleware that was queued during immediate usage
+     */
+    processQueuedMiddleware() {
+        const queue = this.app._middlewareQueue;
+        if (queue && Array.isArray(queue)) {
+            // Process each queued middleware with the full middleware manager
+            queue.forEach(({ handler, options }) => {
+                try {
+                    this.middlewareManager.register(handler, options);
+                }
+                catch (error) {
+                    this.logger.warn("middleware", `Failed to register queued middleware: ${error}`);
+                }
+            });
+            // Clear the queue
+            this.app._middlewareQueue = [];
+        }
+    }
+    /**
+     * Add start method to app with cluster support (full version)
+     */
+    addStartMethod() {
+        const start = async (port, callback) => {
+            // **INTERNAL HANDLING**: Wait for server to be ready before starting
+            // This ensures developers don't need to handle async initialization timing
+            if (!this.ready) {
+                this.logger.debug("server", "Waiting for initialization to complete...");
+                await this.waitForReady();
+                this.logger.info("server", "Initialization complete, starting server...");
+            }
+            const serverPort = port || this.options.server?.port || 3000;
+            const host = this.options.server?.host || "localhost";
+            // If we're in main process and hot reloader is enabled, start it first
+            if (this.fileWatcherManager.isInMainProcess() &&
+                this.fileWatcherManager.getHotReloader()) {
+                this.logger.debug("server", "Taking hot reload mode path");
+                this.logger.startup("fileWatcher", "Starting with hot reload support...");
+                try {
+                    // Start the hot reloader (which will spawn child process)
+                    await this.fileWatcherManager.getHotReloader().start();
+                    // Start file watcher in main process to monitor changes
+                    if (this.fileWatcherManager.getFileWatcher()) {
+                        await this.fileWatcherManager.startFileWatcherWithHotReload();
+                    }
+                    // Start the actual HTTP server in the main process too
+                    this.httpServer = await this.startServerWithPortHandling(serverPort, host, async () => {
+                        this.fileWatcherManager.setHttpServer(this.httpServer);
+                        if (callback)
+                            callback();
+                    });
+                    return this.httpServer;
+                }
+                catch (error) {
+                    this.logger.error("fileWatcher", "Hot reload startup failed:", error.message);
+                    // Fall through to regular startup
+                }
+            }
+            // Regular startup (child process or hot reload disabled)
+            // If cluster is enabled, use cluster manager
+            if (this.clusterManager?.isClusterEnabled()) {
+                this.logger.debug("server", "Taking cluster mode path");
+                // console.log("Starting cluster...");
+                try {
+                    // Start cluster manager
+                    await this.clusterManager.startCluster();
+                    // Check if we're in master or worker process
+                    if (process.env.NODE_ENV !== "worker") {
+                        this.logger.startup("cluster", "Starting as cluster master process");
+                        // Setup cluster event handlers
+                        this.clusterManager.setupClusterEventHandlers();
+                        // Start HTTP server in master process
+                        this.httpServer =
+                            await this.startServerWithPortHandling(serverPort, host, async () => {
+                                // Set HTTP server reference for file watcher restarts
+                                this.fileWatcherManager.setHttpServer(this.httpServer);
+                                const clusterStats = await this.clusterManager.getClusterStats();
+                                this.logger.debug("cluster", `Cluster master started with ${clusterStats.workers?.total || 0} workers`);
+                                // Start file watcher if enabled
+                                if (this.fileWatcherManager.getFileWatcher()) {
+                                    if (this.fileWatcherManager.isInMainProcess()) {
+                                        // Main process: start with hot reload
+                                        await this.fileWatcherManager.startFileWatcherWithHotReload();
+                                    }
+                                    else {
+                                        // Child process: start regular file watcher
+                                        await this.fileWatcherManager.startFileWatcher();
+                                    }
+                                }
+                                if (callback)
+                                    callback();
+                            });
+                        return this.httpServer;
+                    }
+                    else {
+                        // Worker process
+                        this.logger.startup("cluster", `Worker ${process.pid} started`);
+                        const httpServer = await this.startServerWithPortHandling(serverPort, host, () => {
+                            this.logger.info("cluster", `Worker ${process.pid} listening on ${host}:${serverPort}`);
+                            if (callback)
+                                callback();
+                        });
+                        return httpServer;
+                    }
+                }
+                catch (error) {
+                    this.logger.error("cluster", "Failed to start cluster:", error.message);
+                    // Fallback to single process
+                    this.logger.info("cluster", "Falling back to single process mode");
+                }
+            }
+            // Single process mode (default)
+            this.logger.debug("server", "Taking single process mode path");
+            this.httpServer = await this.startServerWithPortHandling(serverPort, host, async () => {
+                // Set HTTP server reference for file watcher restarts
+                this.fileWatcherManager.setHttpServer(this.httpServer);
+                // Start file watcher if enabled
+                if (this.fileWatcherManager.getFileWatcher()) {
+                    if (this.fileWatcherManager.isInMainProcess()) {
+                        // Main process: start with hot reload
+                        await this.fileWatcherManager.startFileWatcherWithHotReload();
+                    }
+                    else {
+                        // Child process: start regular file watcher
+                        await this.fileWatcherManager.startFileWatcher();
+                    }
+                }
+                if (callback)
+                    callback();
+            });
+            return this.httpServer;
+        };
+        this.app.start = start;
+        this.app.waitForReady = () => this.waitForReady();
+        // Add port management methods
+        this.app.getPort = () => this.getPort();
+        this.app.forceClosePort = (port) => this.forceClosePort(port);
+        this.app.redirectFromPort = (fromPort, toPort, options) => this.redirectManager.redirectFromPort(fromPort, toPort, options);
+        // Add advanced redirect management methods
+        this.app.getRedirectInstance = (fromPort) => this.redirectManager.getRedirectInstance(fromPort);
+        this.app.getAllRedirectInstances = () => this.redirectManager.getAllRedirectInstances();
+        this.app.disconnectRedirect = (fromPort) => this.redirectManager.disconnectRedirect(fromPort);
+        this.app.disconnectAllRedirects = () => this.redirectManager.disconnectAllRedirects();
+        this.app.getRedirectStats = (fromPort) => this.redirectManager.getRedirectStats(fromPort);
+        // Cluster methods are already added in constructor if cluster is enabled
+    }
+    // File watcher functionality now handled by FileWatcherManager component
+    /**
+     * Stop file watcher
+     */
+    async stopFileWatcher() {
+        await this.fileWatcherManager.stopFileWatcher();
+    }
+    /**
+     * Get file watcher status
+     */
+    getFileWatcherStatus() {
+        return this.fileWatcherManager.getFileWatcherStatus();
+    }
+    /**
+     * Get file watcher restart stats
+     */
+    getFileWatcherStats() {
+        return this.fileWatcherManager.getFileWatcherStats();
+    }
+    // ===== PLUGIN MANAGEMENT METHODS =====
+    /**
+     * Register a plugin with the server
+     */
+    async registerPlugin(plugin) {
+        await this.pluginManager.registerPlugin(plugin);
+    }
+    /**
+     * Unregister a plugin from the server
+     */
+    async unregisterPlugin(pluginId) {
+        await this.pluginManager.unregisterPlugin(pluginId);
+    }
+    /**
+     * Get plugin by ID
+     */
+    getPlugin(pluginId) {
+        return this.pluginManager.getPlugin(pluginId);
+    }
+    /**
+     * Get all registered plugins
+     */
+    getAllPlugins() {
+        return this.pluginManager.getAllPlugins();
+    }
+    /**
+     * Get plugins by type
+     */
+    getPluginsByType(type) {
+        return this.pluginManager.getPluginsByType(type);
+    }
+    /**
+     * Get plugin execution statistics
+     */
+    getPluginStats(pluginId) {
+        return this.pluginManager.getPluginStats(pluginId);
+    }
+    /**
+     * Get plugin registry statistics
+     */
+    getPluginRegistryStats() {
+        return this.pluginManager.getPluginRegistryStats();
+    }
+    /**
+     * Get plugin engine statistics
+     */
+    getPluginEngineStats() {
+        return this.pluginManager.getPluginEngineStats();
+    }
+    /**
+     * Initialize built-in plugins
+     */
+    async initializeBuiltinPlugins() {
+        try {
+            // Import and register built-in plugins
+            const { JWTAuthPlugin } = await import('./plugins/builtin/JWTAuthPlugin.js');
+            const { ResponseTimePlugin } = await import('./plugins/builtin/ResponseTimePlugin.js');
+            const { SmartCachePlugin } = await import('./plugins/builtin/SmartCachePlugin.js');
+            // Register security plugins
+            await this.registerPlugin(new JWTAuthPlugin());
+            // Register performance plugins
+            await this.registerPlugin(new ResponseTimePlugin());
+            // Register cache plugins
+            await this.registerPlugin(new SmartCachePlugin());
+            this.logger.debug("plugins", "Built-in plugins initialized successfully");
+        }
+        catch (error) {
+            this.logger.error("plugins", "Failed to initialize built-in plugins:", error.message);
+        }
+    }
+    /**
+     * Get comprehensive server statistics including plugins
+     */
+    async getServerStats() {
+        const cacheStats = await this.cacheManager.getCacheStats();
+        const pluginRegistryStats = this.getPluginRegistryStats();
+        const pluginEngineStats = this.getPluginEngineStats();
+        return {
+            server: {
+                ready: this.ready,
+                uptime: process.uptime(),
+                memoryUsage: process.memoryUsage(),
+                cpuUsage: process.cpuUsage(),
+            },
+            cache: cacheStats,
+            plugins: {
+                registry: pluginRegistryStats,
+                engine: pluginEngineStats,
+                totalPlugins: pluginRegistryStats.totalPlugins,
+                averageExecutionTime: pluginRegistryStats.averageExecutionTime,
+            },
+            cluster: await this.clusterManager.getClusterStats(),
+            fileWatcher: this.getFileWatcherStats(),
+        };
+    }
+    // ===== CONSOLE INTERCEPTION METHODS =====
+    /**
+     * Add console interception methods to the Express app
+     */
+    addConsoleInterceptionMethods() {
+        // Get console interceptor instance
+        this.app.getConsoleInterceptor = () => {
+            return this.consoleInterceptor;
+        };
+        // Enable console interception
+        this.app.enableConsoleInterception = () => {
+            this.consoleInterceptor.start();
+        };
+        // Disable console interception
+        this.app.disableConsoleInterception = () => {
+            this.consoleInterceptor.stop();
+        };
+        // Get console interception statistics
+        this.app.getConsoleStats = () => {
+            return this.consoleInterceptor.getStats();
+        };
+        // Reset console interception statistics
+        this.app.resetConsoleStats = () => {
+            this.consoleInterceptor.resetStats();
+        };
+        // File watcher methods
+        this.app.getFileWatcherStatus = () => {
+            return this.getFileWatcherStatus();
+        };
+        this.app.getFileWatcherStats = () => {
+            return this.getFileWatcherStats();
+        };
+        this.app.stopFileWatcher = async () => {
+            return await this.stopFileWatcher();
+        };
+        // TypeScript checking methods
+        this.app.checkTypeScript = async (files) => {
+            return await this.fileWatcherManager.checkTypeScript(files);
+        };
+        this.app.getTypeScriptStatus = () => {
+            return this.fileWatcherManager.getTypeScriptStatus();
+        };
+        this.app.enableTypeScriptChecking = () => {
+            this.fileWatcherManager.enableTypeScriptChecking();
+        };
+        this.app.disableTypeScriptChecking = () => {
+            this.fileWatcherManager.disableTypeScriptChecking();
+        };
+        // Expose FileWatcherManager for debugging and advanced usage
+        this.app.getFileWatcherManager = () => {
+            return this.fileWatcherManager;
+        };
+        // 🔐 Console encryption methods
+        this.app.enableConsoleEncryption = (key) => {
+            this.consoleInterceptor.enableEncryption(key);
+        };
+        this.app.disableConsoleEncryption = () => {
+            this.consoleInterceptor.disableEncryption();
+        };
+        // Simple encrypt method
+        this.app.encrypt = (key) => {
+            this.consoleInterceptor.encrypt(key);
+        };
+        this.app.setConsoleEncryptionKey = (key) => {
+            this.consoleInterceptor.setEncryptionKey(key);
+        };
+        this.app.setConsoleEncryptionDisplayMode = (displayMode, showEncryptionStatus) => {
+            this.consoleInterceptor.setEncryptionDisplayMode(displayMode, showEncryptionStatus);
+        };
+        this.app.getEncryptedLogs = () => {
+            return this.consoleInterceptor.getEncryptedLogs();
+        };
+        this.app.restoreConsoleFromEncrypted = async (encryptedData, key) => {
+            return await this.consoleInterceptor.restoreFromEncrypted(encryptedData, key);
+        };
+        this.app.isConsoleEncryptionEnabled = () => {
+            return this.consoleInterceptor.isEncryptionEnabled();
+        };
+        this.app.getConsoleEncryptionStatus = () => {
+            return this.consoleInterceptor.getEncryptionStatus();
+        };
+    }
+    // ===== PORT MANAGEMENT METHODS =====
+    /**
+     * Get the actual running port number
+     * @returns The current port the server is running on
+     */
+    getPort() {
+        return this.currentPort;
+    }
+    /**
+     * Attempt to forcefully close/free up the specified port
+     * @param port - The port number to force close
+     * @returns Promise<boolean> - true if successful, false if failed
+     */
+    async forceClosePort(port) {
+        return await new Port(port).forceClosePort();
+    }
+    async stop() {
+        // Cleanup ultra-fast processor
+        this.ultraFastProcessor.destroy();
+        // Stop other components
+        if (this.httpServer) {
+            await new Promise((resolve) => {
+                this.httpServer.close(() => resolve());
+            });
+        }
+    }
+}
+
+export { XyPrissServer as FastXyPrissServer, XyPrissServer };
+//# sourceMappingURL=FastServer.js.map