xypriss 1.3.8 → 2.1.0

package/dist/esm/src/server/FastServer.js

@@ -1,5 +1,4 @@
-import express from 'express';
-import rateLimit from 'express-rate-limit';
+import { XyprissApp } from './core/XyprissApp.js';
 import { PluginManager } from './components/fastapi/PluginManager.js';
 import { PluginManager as PluginManager$1 } from '../plugins/plugin-manager.js';
 import '../plugins/modules/core/SecurityPlugin.js';
@@ -38,6 +37,7 @@ import '../../mods/security/src/core/keys/keys-types.js';
 import '../../mods/security/src/core/keys/keys-logger.js';
 import '../../mods/security/src/core/keys/keys-utils.js';
 import '../../mods/security/src/core/keys/algorithms/mods/PBKDF2Algo.js';
+import { SecurityMiddleware } from '../middleware/security-middleware.js';
 import '../../mods/security/src/core/password/index.js';
 import 'systeminformation';
 import 'pidusage';
@@ -54,22 +54,15 @@ 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 { WorkerPoolComponent } from './components/fastapi/WorkerPoolComponent.js';
 import { createSafeJsonMiddleware } from '../middleware/safe-json-middleware.js';
 import { netConfig } from './conf/networkConnectionConf.js';
 import { rateLimitConfig } from './conf/rateLimitConfig.js';
 import { proxyConfig } from './conf/proxyConfig.js';
-import { createNotFoundHandler } from './handlers/NotFoundHandler.js';
+import { ServerLifecycleManager } from './components/lifecycle/ServerLifecycleManager.js';
 
 /**
  * XyPrissJS - Fast and Secure Express Server
@@ -86,7 +79,6 @@ class XyPrissServer {
     }) {
         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
@@ -94,37 +86,34 @@ class XyPrissServer {
         // Initialize logger with user configuration
         this.logger = initializeLogger(this.options.logging);
         this.logger.startup("server", "Creating server...");
-        // Create Express app immediately
-        this.app = express();
+        // Create custom HTTP server app (Express-free)
+        this.app = new XyprissApp(this.logger);
         // 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,
-        });
+        // Initialize lifecycle manager
+        this.initializeLifecycleManager();
         // Add automatic JSON and URL-encoded body parsing (unless disabled)
         if (this.options.server?.autoParseJson !== false) {
             this.addBodyParsingMiddleware();
         }
         // 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");
+        this.logger.debug("server", "XyPriss server created with optimized request processing");
+    }
+    /**
+     * Initialize the ServerLifecycleManager
+     */
+    initializeLifecycleManager() {
+        const dependencies = {
+            app: this.app,
+            options: this.options,
+            logger: this.logger,
+        };
+        this.lifecycleManager = new ServerLifecycleManager(dependencies);
+        // Add start method immediately so it's available right away
+        this.lifecycleManager.addStartMethod(() => this.waitForReady());
     }
     async initializeComponentsAsync() {
         // Initialize components in parallel for faster startup
@@ -134,6 +123,8 @@ class XyPrissServer {
             this.initializePlugins(),
             this.initializeCluster(),
             this.initializeFileWatcher(),
+            this.initializeWorkerPool(),
+            this.initializeSecurity(),
         ]);
         // Initialize components that depend on others
         await this.initializeDependentComponents();
@@ -141,8 +132,10 @@ class XyPrissServer {
         this.routeManager.addMethods();
         this.monitoringManager.addMonitoringEndpoints();
         this.addConsoleInterceptionMethods();
-        // Add custom 404 handler as the last middleware
-        this.app.use(this.notFoundHandler.handler);
+        // Note: 404 handler is now handled properly in HttpServer.handleRequest()
+        // after route matching fails, not as middleware
+        // Mark lifecycle manager as ready
+        this.lifecycleManager.markReady();
         this.ready = true;
     }
     async initializeCache() {
@@ -196,83 +189,71 @@ class XyPrissServer {
             clusterManager: this.clusterManager,
         });
     }
+    async initializeWorkerPool() {
+        // Only initialize worker pool if it's explicitly configured and enabled
+        if (this.options.workerPool?.enabled) {
+            this.workerPoolComponent = new WorkerPoolComponent({
+                workerPool: this.options.workerPool,
+            }, {
+                app: this.app,
+                serverOptions: this.options,
+            });
+        }
+    }
+    async initializeSecurity() {
+        // Initialize security middleware if security is configured and enabled
+        if (this.options.security?.enabled) {
+            this.logger.debug("server", "Initializing security middleware...");
+            // Create security middleware with the provided configuration
+            // The SecurityMiddleware class implements all SecurityConfig options
+            this.securityMiddleware = new SecurityMiddleware(this.options.security, this.logger);
+            // Apply the comprehensive security middleware stack
+            // This handles all security features based on configuration
+            this.app.use(this.securityMiddleware.getMiddleware());
+            this.logger.debug("server", "Security middleware initialized successfully");
+            this.logger.debug("server", `Security level: ${this.options.security.level || "enhanced"}`);
+        }
+        else {
+            this.logger.debug("server", "Security middleware disabled or not configured");
+        }
+    }
     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();
+        // Update lifecycle manager with initialized components
+        this.lifecycleManager.dependencies.cacheManager = this.cacheManager;
+        this.lifecycleManager.dependencies.performanceManager =
+            this.performanceManager;
+        this.lifecycleManager.dependencies.pluginManager = this.pluginManager;
+        this.lifecycleManager.dependencies.clusterManager = this.clusterManager;
+        this.lifecycleManager.dependencies.fileWatcherManager =
+            this.fileWatcherManager;
+        this.lifecycleManager.dependencies.workerPoolComponent =
+            this.workerPoolComponent;
+        // Use lifecycle manager to initialize dependent components
+        await this.lifecycleManager.initializeDependentComponents();
+        // Get the initialized components from lifecycle manager
+        this.routeManager = this.lifecycleManager.dependencies.routeManager;
+        this.monitoringManager =
+            this.lifecycleManager.dependencies.monitoringManager;
+        this.consoleInterceptor =
+            this.lifecycleManager.dependencies.consoleInterceptor;
+        this.notFoundHandler =
+            this.lifecycleManager.dependencies.notFoundHandler;
+        // FastRouteHandler is now available through lifecycle manager
+        // Access it via: this.lifecycleManager.dependencies.fastRouteHandler
         // 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();
         // Initialize network plugins automatically
         await this.initializeNetworkPlugins();
-        this.redirectManager = new RedirectManager(this.logger);
-        this.consoleInterceptor = new ConsoleInterceptor(this.logger, this.options.logging);
-        // Initialize custom 404 handler
-        this.notFoundHandler = createNotFoundHandler(this.options);
-        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");
         }
@@ -283,6 +264,12 @@ class XyPrissServer {
     getApp() {
         return this.app;
     }
+    /**
+     * Get the security middleware instance
+     */
+    getSecurityMiddleware() {
+        return this.securityMiddleware;
+    }
     /**
      * Get the server plugin manager
      */
@@ -346,6 +333,7 @@ class XyPrissServer {
     }
     /**
      * Start server with error handling and port switching
+     * @deprecated - Now handled by ServerLifecycleManager
      */
     async startServerWithPortHandling(port, host, callback) {
         try {
@@ -374,7 +362,7 @@ class XyPrissServer {
             // 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.lifecycleManager.updateState({ 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)
@@ -418,16 +406,13 @@ class XyPrissServer {
      * Add automatic body parsing middleware for JSON and URL-encoded data
      */
     addBodyParsingMiddleware() {
-        // JSON body parsing
-        this.app.use(express.json({
-            limit: this.options.server?.jsonLimit || "10mb",
-        }));
-        // URL-encoded body parsing
-        this.app.use(express.urlencoded({
-            extended: true,
-            limit: this.options.server?.urlEncodedLimit || "10mb",
-        }));
-        this.logger.debug("middleware", "Automatic body parsing middleware added (JSON and URL-encoded)");
+        // Custom JSON body parsing middleware (replaces express.json)
+        this.app.use((_req, _res, next) => {
+            // Body parsing is already handled in CustomHttpServer
+            // This middleware is kept for compatibility
+            next();
+        });
+        this.logger.debug("middleware", "Custom body parsing middleware added (JSON and URL-encoded handled by CustomHttpServer)");
     }
     /**
      * Add safe JSON middleware to handle circular references
@@ -442,153 +427,6 @@ class XyPrissServer {
         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
      */
@@ -752,160 +590,6 @@ class XyPrissServer {
             this.logger.error("server", "Failed to initialize network plugins:", error.message);
         }
     }
-    /**
-     * 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()) {
-                // Double-check we're not in worker mode
-                if (process.env.CLUSTER_MODE === "true" ||
-                    process.env.NODE_ENV === "worker") {
-                    this.logger.debug("server", "Worker mode detected - falling back to single process");
-                    // Fall through to single process mode
-                }
-                else {
-                    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
@@ -1108,7 +792,7 @@ class XyPrissServer {
      * @returns The current port the server is running on
      */
     getPort() {
-        return this.currentPort;
+        return this.lifecycleManager.getCurrentPort();
     }
     /**
      * Attempt to forcefully close/free up the specified port
@@ -1119,8 +803,6 @@ class XyPrissServer {
         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) => {