xypriss 1.0.1 → 1.1.2

package/dist/esm/server/FastServer.js

@@ -1,985 +0,0 @@
-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