dynapm 1.0.11 → 1.0.13

package/dist/src/index.js

@@ -2542,20 +2542,26 @@ var __webpack_modules__ = {
     net: function(module) {
         module.exports = require("net");
     },
+    "node:net": function(module) {
+        module.exports = require("node:net");
+    },
+    "node:url": function(module) {
+        module.exports = require("node:url");
+    },
     stream: function(module) {
         module.exports = require("stream");
     },
     tls: function(module) {
         module.exports = require("tls");
     },
+    "uWebSockets.js": function(module) {
+        module.exports = require("uWebSockets.js");
+    },
     url: function(module) {
         module.exports = require("url");
     },
     zlib: function(module) {
         module.exports = require("zlib");
-    },
-    "uWebSockets.js": function(module) {
-        module.exports = import("uWebSockets.js");
     }
 };
 var __webpack_module_cache__ = {};
@@ -2581,6 +2587,41 @@ function __webpack_require__(moduleId) {
         return getter;
     };
 })();
+(()=>{
+    var getProto = Object.getPrototypeOf ? function(obj) {
+        return Object.getPrototypeOf(obj);
+    } : function(obj) {
+        return obj.__proto__;
+    };
+    var leafPrototypes;
+    __webpack_require__.t = function(value, mode) {
+        if (1 & mode) value = this(value);
+        if (8 & mode) return value;
+        if ('object' == typeof value && value) {
+            if (4 & mode && value.__esModule) return value;
+            if (16 & mode && 'function' == typeof value.then) return value;
+        }
+        var ns = Object.create(null);
+        __webpack_require__.r(ns);
+        var def = {};
+        leafPrototypes = leafPrototypes || [
+            null,
+            getProto({}),
+            getProto([]),
+            getProto(getProto)
+        ];
+        for(var current = 2 & mode && value; 'object' == typeof current && !~leafPrototypes.indexOf(current); current = getProto(current))Object.getOwnPropertyNames(current).forEach(function(key) {
+            def[key] = function() {
+                return value[key];
+            };
+        });
+        def['default'] = function() {
+            return value;
+        };
+        __webpack_require__.d(ns, def);
+        return ns;
+    };
+})();
 (()=>{
     __webpack_require__.d = function(exports1, definition) {
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
@@ -2594,6 +2635,16 @@ function __webpack_require__(moduleId) {
         return Object.prototype.hasOwnProperty.call(obj, prop);
     };
 })();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
 var __webpack_exports__ = {};
 (()=>{
     const external_node_child_process_namespaceObject = require("node:child_process");
@@ -2653,6 +2704,11 @@ var __webpack_exports__ = {};
             }
             lock = (async ()=>{
                 try {
+                    const alreadyRunning = await this.isRunning(service);
+                    if (alreadyRunning) {
+                        console.log(`[${service.name}] 服务已在运行，跳过启动`);
+                        return;
+                    }
                     console.log(`[${service.name}] 正在启动...`);
                     const result = await this.executor.execute(service.commands.start, {
                         cwd: service.commands.cwd,
@@ -2683,30 +2739,309 @@ var __webpack_exports__ = {};
             service._state.status = 'offline';
         }
     }
-    const external_node_net_namespaceObject = require("node:net");
-    var external_node_net_default = /*#__PURE__*/ __webpack_require__.n(external_node_net_namespaceObject);
-    const external_node_http_namespaceObject = require("node:http");
-    var external_node_http_default = /*#__PURE__*/ __webpack_require__.n(external_node_http_namespaceObject);
-    const external_node_https_namespaceObject = require("node:https");
-    var external_node_https_default = /*#__PURE__*/ __webpack_require__.n(external_node_https_namespaceObject);
-    const external_node_url_namespaceObject = require("node:url");
+    var external_uWebSockets_js_ = __webpack_require__("uWebSockets.js");
+    var external_uWebSockets_js_default = /*#__PURE__*/ __webpack_require__.n(external_uWebSockets_js_);
+    var external_node_net_ = __webpack_require__("node:net");
+    var external_node_net_default = /*#__PURE__*/ __webpack_require__.n(external_node_net_);
+    var external_node_url_ = __webpack_require__("node:url");
     __webpack_require__("./node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/stream.js");
     __webpack_require__("./node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/receiver.js");
     __webpack_require__("./node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/sender.js");
     var websocket = __webpack_require__("./node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket.js");
     __webpack_require__("./node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket-server.js");
     const wrapper = websocket;
+    class AdminApiHandler {
+        config;
+        logger;
+        hostnameRoutes;
+        portRoutes;
+        serviceManager;
+        constructor(config, logger, hostnameRoutes, portRoutes, serviceManager){
+            this.config = config;
+            this.logger = logger;
+            this.hostnameRoutes = hostnameRoutes;
+            this.portRoutes = portRoutes;
+            this.serviceManager = serviceManager;
+        }
+        isIpAllowed(ip) {
+            if (!this.config.adminApi?.allowedIps || 0 === this.config.adminApi.allowedIps.length) return true;
+            return this.config.adminApi.allowedIps.includes(ip);
+        }
+        isAuthenticated(authHeader) {
+            if (!this.config.adminApi?.authToken) return true;
+            if (!authHeader) return false;
+            const token = authHeader.replace('Bearer ', '');
+            return token === this.config.adminApi.authToken;
+        }
+        getServiceUptime(service) {
+            if ('online' === service._state.status && service._state.startTime) return service._state.totalUptime + (Date.now() - service._state.startTime);
+            return service._state.totalUptime;
+        }
+        handleAdminApi(res, req) {
+            const ip = req.getHeader('x-forwarded-for')?.split(',')[0]?.trim() || req.getHeader('cf-connecting-ip') || '127.0.0.1';
+            if (!this.isIpAllowed(ip)) {
+                res.cork(()=>{
+                    res.writeStatus('403 Forbidden');
+                    res.end('Forbidden');
+                });
+                this.logger.warn({
+                    msg: `🚫 [Admin API] 拒绝访问: ${ip}`
+                });
+                return;
+            }
+            const authHeader = req.getHeader('authorization');
+            if (!this.isAuthenticated(authHeader)) {
+                res.cork(()=>{
+                    res.writeStatus('401 Unauthorized');
+                    res.writeHeader('WWW-Authenticate', 'Bearer');
+                    res.end('Unauthorized');
+                });
+                return;
+            }
+            const url = req.getUrl();
+            const method = req.getMethod();
+            if ('/_dynapm/api/services' === url && 'get' === method.toLowerCase()) this.getServicesList(res);
+            else if (url.startsWith('/_dynapm/api/services/') && 'get' === method.toLowerCase()) {
+                const serviceName = url.split('/')[4];
+                this.getServiceDetail(res, serviceName);
+            } else if (url.endsWith('/stop') && 'post' === method.toLowerCase()) {
+                const parts = url.split('/');
+                const serviceName = parts[4];
+                this.stopService(res, serviceName);
+            } else if (url.endsWith('/start') && 'post' === method.toLowerCase()) {
+                const parts = url.split('/');
+                const serviceName = parts[4];
+                this.startService(res, serviceName);
+            } else if ('/_dynapm/api/events' === url && 'get' === method.toLowerCase()) this.handleEventStream(res);
+            else res.cork(()=>{
+                res.writeStatus('404 Not Found');
+                res.end('Not Found');
+            });
+        }
+        getServicesList(res) {
+            const serviceMap = new Map();
+            for (const mapping of this.hostnameRoutes.values())serviceMap.set(mapping.service.name, mapping.service);
+            for (const mapping of this.portRoutes.values())serviceMap.set(mapping.service.name, mapping.service);
+            const services = Array.from(serviceMap.values()).map((service)=>({
+                    name: service.name,
+                    base: service.base,
+                    status: service._state.status,
+                    uptime: this.getServiceUptime(service),
+                    lastAccessTime: service._state.lastAccessTime,
+                    activeConnections: service._state.activeConnections,
+                    idleTimeout: service.idleTimeout,
+                    proxyOnly: service.proxyOnly || false,
+                    pid: service._state.pid
+                }));
+            res.cork(()=>{
+                res.writeHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({
+                    services
+                }));
+            });
+        }
+        getServiceDetail(res, serviceName) {
+            const mapping = Array.from(this.hostnameRoutes.values()).find((m)=>m.service.name === serviceName);
+            this.logger.info({
+                msg: `🔍 [Admin API] 查找服务: ${serviceName}, 找到: ${mapping?.service.name || 'null'}`
+            });
+            if (!mapping) {
+                res.cork(()=>{
+                    res.writeStatus('404 Not Found');
+                    res.end(JSON.stringify({
+                        error: 'Service not found'
+                    }));
+                });
+                return;
+            }
+            const service = mapping.service;
+            const detail = {
+                name: service.name,
+                base: service.base,
+                status: service._state.status,
+                uptime: this.getServiceUptime(service),
+                lastAccessTime: service._state.lastAccessTime,
+                activeConnections: service._state.activeConnections,
+                idleTimeout: service.idleTimeout,
+                startTimeout: service.startTimeout,
+                proxyOnly: service.proxyOnly || false,
+                pid: service._state.pid,
+                healthCheck: service.healthCheck || {
+                    type: 'tcp'
+                },
+                startCount: service._state.startCount,
+                totalUptime: service._state.totalUptime
+            };
+            res.cork(()=>{
+                res.writeHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify(detail));
+            });
+        }
+        async stopService(res, serviceName) {
+            const mapping = Array.from(this.hostnameRoutes.values()).find((m)=>m.service.name === serviceName);
+            if (!mapping) {
+                res.cork(()=>{
+                    res.writeStatus('404 Not Found');
+                    res.end(JSON.stringify({
+                        error: 'Service not found'
+                    }));
+                });
+                return;
+            }
+            const service = mapping.service;
+            if ('online' !== service._state.status) {
+                res.cork(()=>{
+                    res.writeStatus('400 Bad Request');
+                    res.end(JSON.stringify({
+                        error: 'Service is not online'
+                    }));
+                });
+                return;
+            }
+            try {
+                service._state.status = 'stopping';
+                if (service._state.startTime) {
+                    service._state.totalUptime += Date.now() - service._state.startTime;
+                    service._state.startTime = void 0;
+                }
+                await this.serviceManager.stop(service);
+                service._state.status = 'offline';
+                res.cork(()=>{
+                    res.writeHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({
+                        success: true,
+                        message: `服务 ${service.name} 已停止`
+                    }));
+                });
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                service._state.status = 'online';
+                res.cork(()=>{
+                    res.writeStatus('500 Internal Server Error');
+                    res.end(JSON.stringify({
+                        error: message
+                    }));
+                });
+            }
+        }
+        async startService(res, serviceName) {
+            const mapping = Array.from(this.hostnameRoutes.values()).find((m)=>m.service.name === serviceName);
+            if (!mapping) {
+                res.cork(()=>{
+                    res.writeStatus('404 Not Found');
+                    res.end(JSON.stringify({
+                        error: 'Service not found'
+                    }));
+                });
+                return;
+            }
+            const service = mapping.service;
+            if ('online' === service._state.status || 'starting' === service._state.status) {
+                res.cork(()=>{
+                    res.writeStatus('400 Bad Request');
+                    res.end(JSON.stringify({
+                        error: 'Service is already running or starting'
+                    }));
+                });
+                return;
+            }
+            try {
+                service._state.status = 'starting';
+                this.serviceManager.start(service).catch((err)=>{
+                    this.logger.error({
+                        msg: `❌ [${service.name}] 启动失败`,
+                        error: err.message
+                    });
+                    service._state.status = 'offline';
+                });
+                const waitStartTime = Date.now();
+                let isReady = false;
+                while(Date.now() - waitStartTime < service.startTimeout){
+                    isReady = await checkTcpPort(service.base);
+                    if (isReady) break;
+                    await new Promise((resolve)=>setTimeout(resolve, 100));
+                }
+                if (!isReady) {
+                    service._state.status = 'offline';
+                    res.cork(()=>{
+                        res.writeStatus('503 Service Unavailable');
+                        res.end(JSON.stringify({
+                            error: 'Service start timeout'
+                        }));
+                    });
+                    return;
+                }
+                service._state.status = 'online';
+                service._state.startTime = Date.now();
+                service._state.startCount++;
+                res.cork(()=>{
+                    res.writeHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({
+                        success: true,
+                        message: `服务 ${service.name} 已启动`
+                    }));
+                });
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                service._state.status = 'offline';
+                res.cork(()=>{
+                    res.writeStatus('500 Internal Server Error');
+                    res.end(JSON.stringify({
+                        error: message
+                    }));
+                });
+            }
+        }
+        handleEventStream(res) {
+            res.cork(()=>{
+                res.writeStatus('200 OK');
+                res.writeHeader('Content-Type', 'text/event-stream');
+                res.writeHeader('Cache-Control', 'no-cache');
+                res.writeHeader('Connection', 'keep-alive');
+                res.writeHeader('X-Accel-Buffering', 'no');
+            });
+            res.cork(()=>{
+                res.end(`event: connected\ndata: {"timestamp":${Date.now()}}\n\n`);
+            });
+        }
+    }
+    function checkTcpPort(url) {
+        const { URL } = __webpack_require__("node:url");
+        const net = __webpack_require__("node:net");
+        const parsed = new URL(url);
+        const host = parsed.hostname;
+        const port = parseInt(parsed.port || ('https:' === parsed.protocol ? '443' : '80'));
+        return new Promise((resolve)=>{
+            const socket = net.createConnection({
+                host,
+                port,
+                timeout: 100
+            }, ()=>{
+                socket.destroy();
+                resolve(true);
+            });
+            socket.on('error', ()=>{
+                socket.destroy();
+                resolve(false);
+            });
+            socket.on('timeout', ()=>{
+                socket.destroy();
+                resolve(false);
+            });
+        });
+    }
     function formatTime(ms) {
         if (ms < 1000) return `${ms}ms`;
         return `${(ms / 1000).toFixed(2)}s`;
     }
+    const external_undici_namespaceObject = require("undici");
     const GatewayConstants = {
         IDLE_CHECK_INTERVAL: 3000,
         TCP_CHECK_TIMEOUT: 100,
         BACKEND_READY_CHECK_DELAY: 50
     };
-    function checkTcpPort(url) {
-        const parsed = new external_node_url_namespaceObject.URL(url);
+    function gateway_checkTcpPort(url) {
+        const parsed = new external_node_url_.URL(url);
         const host = parsed.hostname;
         const port = parseInt(parsed.port || ('https:' === parsed.protocol ? '443' : '80'));
         return new Promise((resolve)=>{
@@ -2731,46 +3066,112 @@ var __webpack_exports__ = {};
     class Gateway {
         config;
         serviceManager;
-        services;
+        hostnameRoutes;
+        portRoutes;
         logger;
+        logging;
+        adminApi;
         constructor(config, logger){
             this.config = config;
             this.serviceManager = new ServiceManager();
-            this.services = new Map();
+            this.hostnameRoutes = new Map();
+            this.portRoutes = new Map();
             this.logger = logger;
+            this.logging = {
+                enableRequestLog: config.logging?.enableRequestLog ?? false,
+                enableWebSocketLog: config.logging?.enableWebSocketLog ?? false,
+                enablePerformanceLog: config.logging?.enablePerformanceLog ?? false
+            };
+            this.adminApi = new AdminApiHandler(config, logger, this.hostnameRoutes, this.portRoutes, this.serviceManager);
             this.initServices();
             this.initIdleChecker();
         }
         initServices() {
-            for (const [hostname, service] of Object.entries(this.config.services)){
+            if (!this.config.services) return;
+            console.log('[DynaPM] 初始化服务...');
+            console.log('[DynaPM] 服务数量:', Object.keys(this.config.services).length);
+            for (const service of Object.values(this.config.services)){
                 service._state = {
-                    status: 'offline',
+                    status: service.proxyOnly ? 'online' : 'offline',
                     lastAccessTime: Date.now(),
-                    activeConnections: 0
+                    activeConnections: 0,
+                    startCount: 0,
+                    totalUptime: 0
                 };
-                this.services.set(hostname, service);
+                const routes = service.routes || [];
+                if (0 === routes.length) {
+                    console.warn(`[DynaPM] ⚠️  [${service.name}] 没有配置路由`);
+                    continue;
+                }
+                console.log(`[DynaPM] ✅ [${service.name}] 配置了 ${routes.length} 个路由:`);
+                for (const route of routes){
+                    const targetUrl = new external_node_url_.URL(route.target);
+                    const undiciClient = new external_undici_namespaceObject.Client(route.target, {
+                        keepAliveTimeout: 60000,
+                        pipelining: 1
+                    });
+                    const mapping = {
+                        service,
+                        target: route.target,
+                        targetUrl,
+                        undiciClient
+                    };
+                    if ('host' === route.type) {
+                        const hostname = route.value;
+                        this.hostnameRoutes.set(hostname, mapping);
+                        console.log(`[DynaPM]   └─ hostname: ${hostname} -> ${route.target}`);
+                    } else if ('port' === route.type) {
+                        const port = route.value;
+                        this.portRoutes.set(port, mapping);
+                        console.log(`[DynaPM]   └─ port: ${port} -> ${route.target}`);
+                    }
+                }
             }
+            const hostnameCount = this.hostnameRoutes.size;
+            const portCount = this.portRoutes.size;
+            console.log(`[DynaPM] 📊 共配置 ${hostnameCount} 个 hostname 映射, ${portCount} 个端口绑定`);
+            this.logger.info({
+                msg: `📊 共配置 ${hostnameCount} 个 hostname 映射, ${portCount} 个端口绑定`
+            });
         }
         initIdleChecker() {
             setInterval(()=>{
                 const now = Date.now();
-                for (const service of this.services.values())if ('online' === service._state.status && 0 === service._state.activeConnections && now - service._state.lastAccessTime > service.idleTimeout) {
-                    this.logger.info({
-                        msg: `🛌 [${service.name}] 闲置超时，正在停止...`
-                    });
-                    this.serviceManager.stop(service).catch((err)=>{
-                        this.logger.error({
-                            msg: `❌ [${service.name}] 停止失败`,
-                            error: err.message
-                        });
-                    });
-                    service._state.status = 'offline';
+                const checkedServices = new Set();
+                for (const mapping of this.hostnameRoutes.values())if (!checkedServices.has(mapping.service)) {
+                    checkedServices.add(mapping.service);
+                    this.checkIdleService(mapping.service, now);
+                }
+                for (const mapping of this.portRoutes.values())if (!checkedServices.has(mapping.service)) {
+                    checkedServices.add(mapping.service);
+                    this.checkIdleService(mapping.service, now);
                 }
             }, GatewayConstants.IDLE_CHECK_INTERVAL);
         }
-        handleRequest(res, req) {
+        checkIdleService(service, now) {
+            if (service.proxyOnly) return;
+            if ('online' === service._state.status && 0 === service._state.activeConnections && now - service._state.lastAccessTime > service.idleTimeout) {
+                this.logger.info({
+                    msg: `🛌 [${service.name}] 闲置超时，正在停止...`
+                });
+                service._state.status = 'stopping';
+                if (service._state.startTime) {
+                    service._state.totalUptime += now - service._state.startTime;
+                    service._state.startTime = void 0;
+                }
+                this.serviceManager.stop(service).catch((err)=>{
+                    this.logger.error({
+                        msg: `❌ [${service.name}] 停止失败`,
+                        error: err.message
+                    });
+                }).finally(()=>{
+                    service._state.status = 'offline';
+                });
+            }
+        }
+        handlePortBindingRequest(res, req, mapping) {
+            const service = mapping.service;
             const startTime = Date.now();
-            const hostname = req.getHeader('host')?.split(':')[0] || '';
             const method = req.getMethod();
             const url = req.getUrl();
             const queryString = req.getQuery();
@@ -2780,8 +3181,33 @@ var __webpack_exports__ = {};
                 const safeValue = value.replace(/[\r\n]/g, '');
                 headers[key] = safeValue;
             });
-            const service = this.services.get(hostname);
-            if (!service) {
+            service._state.lastAccessTime = Date.now();
+            const needsStart = 'offline' === service._state.status;
+            if (needsStart) this.handleServiceStart(res, mapping, fullUrl, startTime, method, headers);
+            else this.handleDirectProxy(res, mapping, fullUrl, startTime, method, headers);
+        }
+        handleRequest(res, req) {
+            const startTime = Date.now();
+            const hostHeader = req.getHeader('host');
+            let hostname = '';
+            if (hostHeader) {
+                const colonIndex = hostHeader.indexOf(':');
+                hostname = -1 !== colonIndex ? hostHeader.substring(0, colonIndex) : hostHeader;
+            }
+            const method = req.getMethod();
+            const url = req.getUrl();
+            const queryString = req.getQuery();
+            const fullUrl = queryString ? url + '?' + queryString : url;
+            const headers = {};
+            req.forEach((key, value)=>{
+                let safeValue = value;
+                const crIndex = value.indexOf('\r');
+                const lfIndex = value.indexOf('\n');
+                if (-1 !== crIndex || -1 !== lfIndex) safeValue = value.replace(/[\r\n]/g, '');
+                headers[key] = safeValue;
+            });
+            const mapping = this.hostnameRoutes.get(hostname);
+            if (!mapping) {
                 this.logger.info({
                     msg: `❌ [${hostname}] ${method} ${fullUrl} - 404`
                 });
@@ -2791,17 +3217,70 @@ var __webpack_exports__ = {};
                 });
                 return;
             }
+            const service = mapping.service;
             service._state.lastAccessTime = Date.now();
-            const needsStart = 'offline' === service._state.status;
-            if (needsStart) this.handleServiceStart(res, service, fullUrl, startTime, method, headers);
-            else this.handleDirectProxy(res, service, fullUrl, startTime, method, headers);
+            const status = service._state.status;
+            const needsStart = 'offline' === status || 'stopping' === status;
+            if (needsStart) {
+                if ('stopping' === status) this.handleServiceWithWait(res, mapping, fullUrl, startTime, method, headers);
+                else this.handleServiceStart(res, mapping, fullUrl, startTime, method, headers);
+            } else this.handleDirectProxy(res, mapping, fullUrl, startTime, method, headers);
         }
-        handleServiceStart(res, service, fullUrl, startTime, method, headers) {
-            const startStartTime = Date.now();
+        async startServiceAndProxy(res, mapping, fullUrl, startTime, method, headers, body) {
+            const service = mapping.service;
+            const target = mapping.target;
             this.logger.info({
                 msg: `🚀 [${service.name}] ${method} ${fullUrl} - 启动服务...`
             });
             service._state.status = 'starting';
+            try {
+                await this.serviceManager.start(service);
+                const waitStartTime = Date.now();
+                let isReady = false;
+                while(Date.now() - waitStartTime < service.startTimeout){
+                    isReady = await gateway_checkTcpPort(target);
+                    if (isReady) {
+                        const waitDuration = Date.now() - waitStartTime;
+                        this.logger.info({
+                            msg: `✅ [${service.name}] 服务就绪 (等待${formatTime(waitDuration)})`
+                        });
+                        break;
+                    }
+                }
+                if (!isReady) {
+                    service._state.status = 'offline';
+                    throw new Error(`服务启动超时: 端口 ${target} 不可用`);
+                }
+                service._state.status = 'online';
+                service._state.startTime = Date.now();
+                service._state.startCount++;
+                await this.forwardProxyRequest(res, mapping, fullUrl, startTime, method, headers, body);
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if ('Client aborted' === message) return;
+                this.logger.error({
+                    msg: `❌ [${service.name}] 启动失败`,
+                    error: message
+                });
+                try {
+                    res.cork(()=>{
+                        res.writeStatus('503 Service Unavailable');
+                        res.end('Service Unavailable');
+                    });
+                } catch (sendErr) {
+                    const sendErrMsg = sendErr instanceof Error ? sendErr.message : String(sendErr);
+                    this.logger.error({
+                        msg: `❌ [${service.name}] 发送错误响应失败`,
+                        error: sendErrMsg
+                    });
+                }
+            }
+        }
+        handleServiceWithWait(res, mapping, fullUrl, startTime, method, headers) {
+            const service = mapping.service;
+            this.logger.info({
+                msg: `⏳ [${service.name}] ${method} ${fullUrl} - 等待服务停止完成...`
+            });
             const chunks = [];
             let aborted = false;
             res.onAborted(()=>{
@@ -2813,46 +3292,35 @@ var __webpack_exports__ = {};
                 chunks.push(chunk);
                 if (isLast) {
                     const fullBody = Buffer.concat(chunks);
+                    if (aborted) return;
                     (async ()=>{
-                        try {
-                            await this.serviceManager.start(service);
-                            const waitStartTime = Date.now();
-                            let isReady = false;
-                            while(Date.now() - waitStartTime < service.startTimeout){
-                                isReady = await checkTcpPort(service.base);
-                                if (isReady) {
-                                    const waitDuration = Date.now() - waitStartTime;
-                                    const totalDuration = Date.now() - startStartTime;
-                                    this.logger.info({
-                                        msg: `✅ [${service.name}] 服务就绪 (启动${formatTime(totalDuration - waitDuration)}, 等待${formatTime(waitDuration)})`
-                                    });
-                                    break;
-                                }
-                            }
-                            if (!isReady) {
-                                service._state.status = 'offline';
-                                throw new Error(`服务启动超时: 端口 ${service.base} 不可用`);
+                        const maxWaitTime = 30000;
+                        const checkInterval = 100;
+                        const waitStartTime = Date.now();
+                        while('stopping' === service._state.status){
+                            if (Date.now() - waitStartTime > maxWaitTime) {
+                                this.logger.error({
+                                    msg: `❌ [${service.name}] 等待服务停止超时`
+                                });
+                                res.cork(()=>{
+                                    res.writeStatus('503 Service Unavailable');
+                                    res.end('Service stopping timeout');
+                                });
+                                return;
                             }
-                            service._state.status = 'online';
-                            if (aborted) return;
-                            await this.forwardProxyRequest(res, service, fullUrl, startTime, method, headers, fullBody);
-                        } catch (error) {
-                            const message = error instanceof Error ? error.message : String(error);
-                            if ('Client aborted' === message) return;
-                            this.logger.error({
-                                msg: `❌ [${service.name}] 启动失败`,
-                                error: message
-                            });
-                            if (!aborted) res.cork(()=>{
-                                res.writeStatus('503 Service Unavailable');
-                                res.end('Service Unavailable');
-                            });
+                            await new Promise((resolve)=>setTimeout(resolve, checkInterval));
                         }
+                        if (aborted) return;
+                        this.logger.info({
+                            msg: `✅ [${service.name}] 服务已停止，开始启动...`
+                        });
+                        await this.startServiceAndProxy(res, mapping, fullUrl, startTime, method, headers, fullBody);
                     })();
                 }
             });
         }
-        handleDirectProxy(res, service, fullUrl, startTime, method, headers) {
+        handleServiceStart(res, mapping, fullUrl, startTime, method, headers) {
+            mapping.service;
             const chunks = [];
             let aborted = false;
             res.onAborted(()=>{
@@ -2865,74 +3333,108 @@ var __webpack_exports__ = {};
                 if (isLast) {
                     const fullBody = Buffer.concat(chunks);
                     if (aborted) return;
-                    this.forwardProxyRequest(res, service, fullUrl, startTime, method, headers, fullBody).catch((err)=>{
+                    this.startServiceAndProxy(res, mapping, fullUrl, startTime, method, headers, fullBody);
+                }
+            });
+        }
+        handleDirectProxy(res, mapping, fullUrl, startTime, method, headers) {
+            const service = mapping.service;
+            const chunks = [];
+            let aborted = false;
+            res.onAborted(()=>{
+                aborted = true;
+            });
+            res.onData((ab, isLast)=>{
+                if (aborted) return;
+                const chunk = Buffer.from(ab);
+                chunks.push(chunk);
+                if (isLast) {
+                    const fullBody = 1 === chunks.length ? chunks[0] : Buffer.concat(chunks);
+                    if (aborted) return;
+                    this.forwardProxyRequest(res, mapping, fullUrl, startTime, method, headers, fullBody).catch((err)=>{
                         if ('Client aborted' === err.message) return;
                         this.logger.error({
                             msg: `❌ [${service.name}] 代理失败`,
                             error: err.message
                         });
-                        if (!aborted) res.cork(()=>{
-                            res.writeStatus('500 Internal Server Error');
-                            res.end('Proxy Error');
-                        });
+                        if (!aborted) try {
+                            res.cork(()=>{
+                                res.writeStatus('500 Internal Server Error');
+                                res.end('Proxy Error');
+                            });
+                        } catch (sendErr) {
+                            const sendErrMsg = sendErr instanceof Error ? sendErr.message : String(sendErr);
+                            this.logger.error({
+                                msg: `❌ [${service.name}] 发送错误响应失败`,
+                                error: sendErrMsg
+                            });
+                        }
                     });
                 }
             });
         }
-        async forwardProxyRequest(res, service, path, startTime, method, headers, body) {
-            const targetUrl = new external_node_url_namespaceObject.URL(service.base + path);
-            const isHttps = 'https:' === targetUrl.protocol;
-            const httpModule = isHttps ? external_node_https_default() : external_node_http_default();
-            const proxyHeaders = {
-                ...headers
-            };
-            delete proxyHeaders['connection'];
-            delete proxyHeaders['keep-alive'];
+        async forwardProxyRequest(res, mapping, path, startTime, method, headers, body) {
+            const service = mapping.service;
+            const perfLog = this.logging.enablePerformanceLog;
+            const perfPrepStart = perfLog ? performance.now() : 0;
+            const targetUrl = mapping.targetUrl;
+            const perfUrlTime = perfLog ? performance.now() - perfPrepStart : 0;
+            const proxyHeaders = {};
+            for(const key in headers)if ('connection' !== key && 'keep-alive' !== key) proxyHeaders[key] = headers[key];
             proxyHeaders['host'] = targetUrl.host;
+            const perfHeadersTime = perfLog ? performance.now() - perfPrepStart - perfUrlTime : 0;
             const state = {
                 aborted: false,
                 responded: false
             };
             service._state.activeConnections++;
+            const perfPrepTime = perfLog ? performance.now() - perfPrepStart : 0;
             return new Promise((resolve, reject)=>{
+                let cleaned = false;
                 const cleanup = ()=>{
-                    service._state.activeConnections--;
+                    if (!cleaned) {
+                        cleaned = true;
+                        service._state.activeConnections--;
+                    }
                 };
                 res.onAborted(()=>{
                     state.aborted = true;
-                    if (state.proxyReq && !state.proxyReq.destroyed) state.proxyReq.destroy();
-                    if (state.proxyRes && !state.proxyRes.destroyed) state.proxyRes.destroy();
                     cleanup();
                     resolve();
                 });
-                state.proxyReq = httpModule.request(targetUrl, {
+                const perfHttpStart = perfLog ? performance.now() : 0;
+                let perfTtfb = 0;
+                let perfStreamStart = 0;
+                let chunkCount = 0;
+                let totalBytes = 0;
+                const undiciClient = mapping.undiciClient;
+                undiciClient.request({
+                    path,
                     method,
                     headers: proxyHeaders,
-                    rejectUnauthorized: false
-                }, (proxyRes)=>{
-                    state.proxyRes = proxyRes;
-                    const statusCode = proxyRes.statusCode || 200;
-                    const statusMessage = proxyRes.statusMessage || 'OK';
+                    body
+                }).then(({ statusCode, headers, body })=>{
+                    if (perfLog && 0 === perfTtfb) {
+                        perfTtfb = performance.now() - perfHttpStart;
+                        perfStreamStart = performance.now();
+                    }
+                    const statusMessage = 'OK';
                     if (state.aborted) {
-                        proxyRes.destroy();
+                        body.destroy();
                         cleanup();
                         resolve();
                         return;
                     }
                     if (101 === statusCode) {
-                        this.logger.info({
-                            msg: `✅ [${service.name}] WebSocket 升级成功`
-                        });
                         res.cork(()=>{
                             if (state.aborted) return;
                             res.writeStatus(`${statusCode} ${statusMessage}`);
-                            const responseHeaders = proxyRes.headers;
-                            for (const [key, value] of Object.entries(responseHeaders)){
+                            for(const key in headers){
                                 const keyLower = key.toLowerCase();
-                                if ('connection' !== keyLower && 'transfer-encoding' !== keyLower && 'keep-alive' !== keyLower) {
-                                    if (Array.isArray(value)) for (const v of value)res.writeHeader(key, v);
-                                    else if (void 0 !== value) res.writeHeader(key, value);
-                                }
+                                if ('connection' === keyLower || 'transfer-encoding' === keyLower || 'keep-alive' === keyLower) continue;
+                                const value = headers[key];
+                                if (Array.isArray(value)) for (const v of value)res.writeHeader(key, v);
+                                else if (void 0 !== value) res.writeHeader(key, value);
                             }
                             res.end();
                             state.responded = true;
@@ -2944,61 +3446,82 @@ var __webpack_exports__ = {};
                     res.cork(()=>{
                         if (state.aborted) return;
                         res.writeStatus(`${statusCode} ${statusMessage}`);
-                        const responseHeaders = proxyRes.headers;
-                        for (const [key, value] of Object.entries(responseHeaders)){
+                        for(const key in headers){
                             const keyLower = key.toLowerCase();
-                            if ('connection' !== keyLower && 'transfer-encoding' !== keyLower && 'keep-alive' !== keyLower) {
-                                if (Array.isArray(value)) for (const v of value)res.writeHeader(key, v);
-                                else if (void 0 !== value) res.writeHeader(key, value);
-                            }
+                            if ('connection' === keyLower || 'transfer-encoding' === keyLower || 'keep-alive' === keyLower) continue;
+                            const value = headers[key];
+                            if (Array.isArray(value)) for (const v of value)res.writeHeader(key, v);
+                            else if (void 0 !== value) res.writeHeader(key, value);
                         }
                     });
-                    proxyRes.on('data', (chunk)=>{
+                    body.on('data', (chunk)=>{
                         if (state.aborted) {
-                            proxyRes.destroy();
+                            body.destroy();
                             return;
                         }
+                        if (perfLog) {
+                            chunkCount++;
+                            totalBytes += chunk.length;
+                        }
                         let writeSuccess = false;
                         res.cork(()=>{
                             if (state.aborted) return;
                             writeSuccess = res.write(chunk);
                         });
                         if (!writeSuccess) {
-                            proxyRes.pause();
+                            body.pause();
                             res.onWritable(()=>{
                                 if (state.aborted) {
-                                    proxyRes.destroy();
+                                    body.destroy();
                                     return false;
                                 }
-                                proxyRes.resume();
+                                body.resume();
                                 return true;
                             });
                         }
                     });
-                    proxyRes.on('end', ()=>{
+                    body.on('end', ()=>{
                         if (state.aborted) {
                             cleanup();
                             resolve();
                             return;
                         }
+                        const perfStreamTime = perfLog ? performance.now() - perfStreamStart : 0;
+                        const perfTotalTime = perfLog ? performance.now() - perfPrepStart : 0;
                         res.cork(()=>{
                             if (state.aborted) return;
                             res.end();
                             state.responded = true;
-                            const responseTime = Date.now() - startTime;
-                            this.logger.info({
-                                msg: `📤 [${service.name}] ${method} ${path} - ${statusCode} - ${formatTime(responseTime)}`,
-                                service: service.name,
+                            if (this.logging.enableRequestLog) {
+                                const responseTime = Date.now() - startTime;
+                                this.logger.info({
+                                    msg: `📤 [${service.name}] ${method} ${path} - ${statusCode} - ${formatTime(responseTime)}`,
+                                    service: service.name,
+                                    method,
+                                    path,
+                                    statusCode,
+                                    responseTime
+                                });
+                            }
+                            if (perfLog) console.error(`⚡ [${service.name}] 性能分析:`, {
                                 method,
                                 path,
                                 statusCode,
-                                responseTime
+                                prepTime: perfPrepTime.toFixed(3) + 'ms',
+                                urlTime: perfUrlTime.toFixed(3) + 'ms',
+                                headersTime: perfHeadersTime.toFixed(3) + 'ms',
+                                ttfb: perfTtfb.toFixed(3) + 'ms',
+                                streamTime: perfStreamTime.toFixed(3) + 'ms',
+                                totalTime: perfTotalTime.toFixed(3) + 'ms',
+                                chunkCount,
+                                totalBytes,
+                                avgChunkSize: chunkCount > 0 ? (totalBytes / chunkCount).toFixed(1) + 'B' : '0B'
                             });
                         });
                         cleanup();
                         resolve();
                     });
-                    proxyRes.on('error', (err)=>{
+                    body.on('error', (err)=>{
                         if (state.aborted) {
                             cleanup();
                             resolve();
@@ -3008,7 +3531,7 @@ var __webpack_exports__ = {};
                             msg: `❌ [${service.name}] 代理响应错误`,
                             error: err.message
                         });
-                        if (!state.responded) {
+                        if (!state.responded && !state.aborted) {
                             state.responded = true;
                             try {
                                 res.cork(()=>{
@@ -3017,13 +3540,18 @@ var __webpack_exports__ = {};
                                         res.end('Bad Gateway');
                                     }
                                 });
-                            } catch  {}
+                            } catch (sendErr) {
+                                const sendErrMsg = sendErr instanceof Error ? sendErr.message : String(sendErr);
+                                this.logger.error({
+                                    msg: `❌ [${service.name}] 发送错误响应失败`,
+                                    error: sendErrMsg
+                                });
+                            }
                         }
                         cleanup();
                         reject(err);
                     });
-                });
-                state.proxyReq.on('error', (err)=>{
+                }).catch((err)=>{
                     if (state.aborted) {
                         cleanup();
                         resolve();
@@ -3033,7 +3561,7 @@ var __webpack_exports__ = {};
                         msg: `❌ [${service.name}] 代理请求错误`,
                         error: err.message
                     });
-                    if (!state.responded) {
+                    if (!state.responded && !state.aborted) {
                         state.responded = true;
                         try {
                             res.cork(()=>{
@@ -3042,45 +3570,60 @@ var __webpack_exports__ = {};
                                     res.end('Bad Gateway');
                                 }
                             });
-                        } catch  {}
+                        } catch (sendErr) {
+                            const sendErrMsg = sendErr instanceof Error ? sendErr.message : String(sendErr);
+                            this.logger.error({
+                                msg: `❌ [${service.name}] 发送错误响应失败`,
+                                error: sendErrMsg
+                            });
+                        }
                     }
                     cleanup();
                     reject(err);
                 });
-                state.proxyReq.write(body);
-                state.proxyReq.end();
             });
         }
         async start() {
-            const uWS = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "uWebSockets.js"));
+            const uWS = await Promise.resolve().then(__webpack_require__.t.bind(__webpack_require__, "uWebSockets.js", 23));
             const host = this.config.host || '127.0.0.1';
             const port = this.config.port || 3000;
             const app = uWS.App();
             app.ws('/*', {
                 upgrade: (res, req, context)=>{
                     const hostname = req.getHeader('host')?.split(':')[0] || '';
-                    const service = this.services.get(hostname);
-                    if (!service) {
+                    const mapping = this.hostnameRoutes.get(hostname);
+                    if (!mapping) {
                         res.cork(()=>{
                             res.writeStatus('404 Not Found');
                             res.end(`Service not found: ${hostname}`);
                         });
                         return;
                     }
+                    const { service, target } = mapping;
                     service._state.lastAccessTime = Date.now();
+                    const clientHeaders = {};
+                    req.forEach((key, value)=>{
+                        const safeValue = value.replace(/[\r\n]/g, '');
+                        clientHeaders[key] = safeValue;
+                    });
+                    const clientPath = req.getUrl() + (req.getQuery() ? `?${req.getQuery()}` : '');
                     res.upgrade({
                         hostname,
-                        service
+                        service,
+                        target,
+                        clientHeaders,
+                        clientPath
                     }, req.getHeader('sec-websocket-key'), req.getHeader('sec-websocket-protocol'), req.getHeader('sec-websocket-extensions'), context);
-                    this.logger.info({
-                        msg: `🔌 [${service.name}] WebSocket 升级请求`
+                    if (this.logging.enableWebSocketLog) this.logger.info({
+                        msg: `🔌 [${service.name}] WebSocket 升级请求: ${clientPath}`
                     });
                 },
                 open: (ws)=>{
                     const userData = ws.getUserData();
                     const service = userData.service;
+                    const target = userData.target;
                     service._state.activeConnections++;
-                    this.logger.info({
+                    if (this.logging.enableWebSocketLog) this.logger.info({
                         msg: `🔌 [${service.name}] WebSocket 连接已建立`
                     });
                     const wsState = {
@@ -3102,7 +3645,7 @@ var __webpack_exports__ = {};
                                 const waitStartTime = Date.now();
                                 let isReady = false;
                                 while(Date.now() - waitStartTime < service.startTimeout){
-                                    isReady = await checkTcpPort(service.base);
+                                    isReady = await gateway_checkTcpPort(target);
                                     if (isReady) {
                                         const waitDuration = Date.now() - waitStartTime;
                                         this.logger.info({
@@ -3121,30 +3664,47 @@ var __webpack_exports__ = {};
                                     return;
                                 }
                                 service._state.status = 'online';
+                                service._state.startTime = Date.now();
+                                service._state.startCount++;
                             }
-                            const targetUrl = new external_node_url_namespaceObject.URL(service.base);
-                            const wsUrl = `${'https:' === targetUrl.protocol ? 'wss:' : 'ws:'}//${targetUrl.host}/`;
-                            this.logger.info({
+                            const targetUrl = new external_node_url_.URL(target);
+                            const userData = ws.getUserData();
+                            const clientPath = userData.clientPath;
+                            const clientHeaders = userData.clientHeaders;
+                            const wsUrl = `${'https:' === targetUrl.protocol ? 'wss:' : 'ws:'}//${targetUrl.host}${clientPath}`;
+                            if (this.logging.enableWebSocketLog) this.logger.info({
                                 msg: `🔌 [${service.name}] 连接后端 WebSocket: ${wsUrl}`
                             });
+                            const backendHeaders = {};
+                            const skipHeaders = new Set([
+                                'host',
+                                'connection',
+                                'upgrade',
+                                'sec-websocket-key',
+                                'sec-websocket-version'
+                            ]);
+                            for (const [key, value] of Object.entries(clientHeaders))if (!skipHeaders.has(key.toLowerCase())) backendHeaders[key] = value;
+                            backendHeaders['Host'] = targetUrl.host;
+                            this.logger.info({
+                                msg: `🔌 [${service.name}] 转发 WebSocket 请求头`,
+                                headers: JSON.stringify(backendHeaders, null, 2)
+                            });
                             const backendWs = new wrapper(wsUrl, {
-                                headers: {
-                                    Host: targetUrl.host
-                                }
+                                headers: backendHeaders
                             });
                             wsState.backendWs = backendWs;
                             backendWs.on('open', ()=>{
-                                this.logger.info({
+                                if (this.logging.enableWebSocketLog) this.logger.info({
                                     msg: `✅ [${service.name}] 后端 WebSocket 连接已建立`
                                 });
                                 wsState.backendReady = true;
-                                this.logger.info({
+                                if (this.logging.enableWebSocketLog) this.logger.info({
                                     msg: `📤 [${service.name}] 发送队列中的 ${wsState.messageQueue.length} 条消息`
                                 });
                                 while(wsState.messageQueue.length > 0 && backendWs.readyState === wrapper.OPEN){
                                     const msg = wsState.messageQueue.shift();
                                     if (msg) {
-                                        this.logger.info({
+                                        if (this.logging.enableWebSocketLog) this.logger.info({
                                             msg: `📨 [${service.name}] 发送队列消息: ${msg.length} 字节`
                                         });
                                         backendWs.send(msg);
@@ -3169,7 +3729,7 @@ var __webpack_exports__ = {};
                                 }
                             });
                             backendWs.on('close', ()=>{
-                                this.logger.info({
+                                if (this.logging.enableWebSocketLog) this.logger.info({
                                     msg: `🔌 [${service.name}] 后端 WebSocket 连接关闭`
                                 });
                                 if (null !== ws && !wsState.closing) {
@@ -3182,15 +3742,16 @@ var __webpack_exports__ = {};
                                     msg: `❌ [${service.name}] 后端 WebSocket 错误`,
                                     error: err.message
                                 });
+                                wsState.closing = true;
                                 if (null !== ws) ws.close();
                             });
                             backendWs.on('pause', ()=>{
-                                this.logger.info({
+                                if (this.logging.enableWebSocketLog) this.logger.info({
                                     msg: `⏸️ [${service.name}] 后端 WebSocket 暂停（背压）`
                                 });
                             });
                             backendWs.on('resume', ()=>{
-                                this.logger.info({
+                                if (this.logging.enableWebSocketLog) this.logger.info({
                                     msg: `▶️ [${service.name}] 后端 WebSocket 恢复`
                                 });
                             });
@@ -3200,7 +3761,7 @@ var __webpack_exports__ = {};
                                 msg: `❌ [${service.name}] WebSocket 连接失败`,
                                 error: message
                             });
-                            ws.close();
+                            if (null !== ws) ws.close();
                         }
                     })();
                 },
@@ -3210,13 +3771,13 @@ var __webpack_exports__ = {};
                     const wsState = ws.wsState;
                     if (wsState.backendReady && wsState.backendWs && wsState.backendWs.readyState === wrapper.OPEN) {
                         const msgBuffer = Buffer.from(message);
-                        this.logger.info({
+                        if (this.logging.enableWebSocketLog) this.logger.info({
                             msg: `📨 [${service.name}] 转发消息到后端: ${msgBuffer.length} 字节`
                         });
                         wsState.backendWs.send(msgBuffer);
                         service._state.lastAccessTime = Date.now();
                     } else {
-                        this.logger.info({
+                        if (this.logging.enableWebSocketLog) this.logger.info({
                             msg: `📦 [${service.name}] 消息加入队列`
                         });
                         wsState.messageQueue.push(Buffer.from(message));
@@ -3226,7 +3787,7 @@ var __webpack_exports__ = {};
                     const userData = ws.getUserData();
                     const service = userData.service;
                     service._state.activeConnections--;
-                    this.logger.info({
+                    if (this.logging.enableWebSocketLog) this.logger.info({
                         msg: `🔌 [${service.name}] 客户端 WebSocket 连接关闭`
                     });
                     const wsState = ws.wsState;
@@ -3247,6 +3808,195 @@ var __webpack_exports__ = {};
                     msg: `❌ DynaPM 网关启动失败: ${host}:${port}`
                 });
             });
+            for (const [portNum, mapping] of this.portRoutes)this.createPortBindingListener(host, portNum, mapping);
+            const adminApiConfig = this.config.adminApi;
+            if (adminApiConfig && false !== adminApiConfig.enabled && adminApiConfig.port) this.createAdminApiListener(host, adminApiConfig.port);
+        }
+        createAdminApiListener(host, port) {
+            const app = external_uWebSockets_js_default().App();
+            app.any('/*', (res, req)=>{
+                this.adminApi.handleAdminApi(res, req);
+            });
+            app.listen(host, port, (token)=>{
+                if (token) this.logger.info({
+                    msg: `🔌 管理 API 已启动: http://${host}:${port}`
+                });
+                else this.logger.error({
+                    msg: `❌ 管理 API 启动失败: ${host}:${port}`
+                });
+            });
+        }
+        createPortBindingListener(host, portNum, mapping) {
+            const { service, target } = mapping;
+            const app = external_uWebSockets_js_default().App();
+            app.ws('/*', {
+                upgrade: (res, req, context)=>{
+                    service._state.lastAccessTime = Date.now();
+                    const clientHeaders = {};
+                    req.forEach((key, value)=>{
+                        const safeValue = value.replace(/[\r\n]/g, '');
+                        clientHeaders[key] = safeValue;
+                    });
+                    const clientPath = req.getUrl() + (req.getQuery() ? `?${req.getQuery()}` : '');
+                    res.upgrade({
+                        service,
+                        target,
+                        clientHeaders,
+                        clientPath
+                    }, req.getHeader('sec-websocket-key'), req.getHeader('sec-websocket-protocol'), req.getHeader('sec-websocket-extensions'), context);
+                    if (this.logging.enableWebSocketLog) this.logger.info({
+                        msg: `🔌 [${service.name}] 端口${portNum} WebSocket 升级请求: ${clientPath}`
+                    });
+                },
+                open: (ws)=>{
+                    const userData = ws.getUserData();
+                    const svc = userData.service;
+                    const backendTarget = userData.target;
+                    svc._state.activeConnections++;
+                    if (this.logging.enableWebSocketLog) this.logger.info({
+                        msg: `🔌 [${svc.name}] 端口${portNum} WebSocket 连接已建立`
+                    });
+                    const wsState = {
+                        backendReady: false,
+                        messageQueue: [],
+                        backendWs: void 0,
+                        closing: false
+                    };
+                    ws.wsState = wsState;
+                    (async ()=>{
+                        try {
+                            const needsStart = 'offline' === svc._state.status;
+                            if (needsStart) {
+                                this.logger.info({
+                                    msg: `🚀 [${svc.name}] 端口${portNum} WebSocket - 启动服务...`
+                                });
+                                svc._state.status = 'starting';
+                                await this.serviceManager.start(svc);
+                                const waitStartTime = Date.now();
+                                let isReady = false;
+                                while(Date.now() - waitStartTime < svc.startTimeout){
+                                    isReady = await gateway_checkTcpPort(backendTarget);
+                                    if (isReady) {
+                                        const waitDuration = Date.now() - waitStartTime;
+                                        this.logger.info({
+                                            msg: `✅ [${svc.name}] 端口${portNum} WebSocket 服务就绪 (等待${formatTime(waitDuration)})`
+                                        });
+                                        break;
+                                    }
+                                    await new Promise((resolve)=>setTimeout(resolve, GatewayConstants.BACKEND_READY_CHECK_DELAY));
+                                }
+                                if (!isReady) {
+                                    svc._state.status = 'offline';
+                                    this.logger.error({
+                                        msg: `❌ [${svc.name}] 端口${portNum} WebSocket 服务启动超时`
+                                    });
+                                    ws.close();
+                                    return;
+                                }
+                                svc._state.status = 'online';
+                                svc._state.startTime = Date.now();
+                                svc._state.startCount++;
+                            }
+                            const targetUrl = new external_node_url_.URL(backendTarget);
+                            const userData = ws.getUserData();
+                            const clientPath = userData.clientPath;
+                            const clientHeaders = userData.clientHeaders;
+                            const wsUrl = `${'https:' === targetUrl.protocol ? 'wss:' : 'ws:'}//${targetUrl.host}${clientPath}`;
+                            if (this.logging.enableWebSocketLog) this.logger.info({
+                                msg: `🔌 [${svc.name}] 端口${portNum} 连接后端 WebSocket: ${wsUrl}`
+                            });
+                            const backendHeaders = {};
+                            const skipHeaders = new Set([
+                                'host',
+                                'connection',
+                                'upgrade',
+                                'sec-websocket-key',
+                                'sec-websocket-version'
+                            ]);
+                            for (const [key, value] of Object.entries(clientHeaders))if (!skipHeaders.has(key.toLowerCase())) backendHeaders[key] = value;
+                            backendHeaders['Host'] = targetUrl.host;
+                            const backendWs = new wrapper(wsUrl, {
+                                headers: backendHeaders
+                            });
+                            wsState.backendWs = backendWs;
+                            backendWs.on('open', ()=>{
+                                if (this.logging.enableWebSocketLog) this.logger.info({
+                                    msg: `✅ [${svc.name}] 端口${portNum} 后端 WebSocket 连接已建立`
+                                });
+                                wsState.backendReady = true;
+                                while(wsState.messageQueue.length > 0 && backendWs.readyState === wrapper.OPEN){
+                                    const msg = wsState.messageQueue.shift();
+                                    if (msg) backendWs.send(msg);
+                                }
+                            });
+                            backendWs.on('message', (data, isBinary)=>{
+                                if (null !== ws) ws.send(data, isBinary, false);
+                            });
+                            backendWs.on('close', ()=>{
+                                if (null !== ws && !wsState.closing) {
+                                    wsState.closing = true;
+                                    ws.close();
+                                }
+                            });
+                            backendWs.on('error', ()=>{
+                                wsState.closing = true;
+                                if (null !== ws) ws.close();
+                            });
+                        } catch (error) {
+                            const message = error instanceof Error ? error.message : String(error);
+                            this.logger.error({
+                                msg: `❌ [${service.name}] WebSocket 连接失败`,
+                                error: message
+                            });
+                            if (null !== ws) ws.close();
+                        }
+                    })();
+                },
+                message: (ws, message, _isBinary)=>{
+                    const userData = ws.getUserData();
+                    const svc = userData.service;
+                    const wsState = ws.wsState;
+                    if (wsState.backendReady && wsState.backendWs && wsState.backendWs.readyState === wrapper.OPEN) {
+                        wsState.backendWs.send(Buffer.from(message));
+                        svc._state.lastAccessTime = Date.now();
+                    } else wsState.messageQueue.push(Buffer.from(message));
+                },
+                close: (ws)=>{
+                    const userData = ws.getUserData();
+                    const svc = userData.service;
+                    svc._state.activeConnections--;
+                }
+            });
+            app.any('/*', (res, req)=>{
+                this.handlePortBindingRequest(res, req, mapping);
+            });
+            app.listen(host, portNum, (token)=>{
+                if (token) this.logger.info({
+                    msg: `🔌 端口绑定已启动: http://${host}:${portNum} -> ${service.name}`
+                });
+                else this.logger.error({
+                    msg: `❌ 端口绑定启动失败: ${host}:${portNum}`
+                });
+            });
+        }
+        async cleanup() {
+            this.logger.info({
+                msg: '🧹 正在清理所有服务...'
+            });
+            const cleanedServices = new Set();
+            for (const mapping of this.hostnameRoutes.values())cleanedServices.add(mapping.service);
+            for (const mapping of this.portRoutes.values())cleanedServices.add(mapping.service);
+            const stopPromises = [];
+            for (const service of cleanedServices)if ('online' === service._state.status || 'starting' === service._state.status) stopPromises.push(this.serviceManager.stop(service).catch((err)=>{
+                this.logger.error({
+                    msg: `❌ [${service.name}] 停止失败`,
+                    error: err.message
+                });
+            }));
+            await Promise.all(stopPromises);
+            this.logger.info({
+                msg: `✅ 已清理 ${cleanedServices.size} 个服务`
+            });
         }
     }
     const external_c12_namespaceObject = require("c12");
@@ -3256,18 +4006,65 @@ var __webpack_exports__ = {};
             defaultConfig: {
                 port: 3000,
                 host: '127.0.0.1',
-                services: {}
+                services: {},
+                adminApi: {
+                    enabled: true,
+                    port: 4000,
+                    allowedIps: [
+                        '127.0.0.1',
+                        '::1'
+                    ]
+                }
             }
         });
         if (!config.services || 0 === Object.keys(config.services).length) throw new Error('配置文件中至少需要一个服务');
-        for (const [hostname, service] of Object.entries(config.services)){
-            service.name = service.name || hostname;
+        const mainPort = config.port || 3000;
+        if (config.adminApi?.enabled && config.adminApi.port === mainPort) throw new Error(`管理 API 端口 ${mainPort} 与主端口冲突`);
+        const portMap = new Map();
+        const hostnameMap = new Map();
+        for (const [key, service] of Object.entries(config.services)){
+            service.name = service.name || key;
             service.idleTimeout = service.idleTimeout || 300000;
             service.startTimeout = service.startTimeout || 30000;
             service.healthCheck = service.healthCheck || {
                 type: 'tcp'
             };
             if ('http' === service.healthCheck.type && !service.healthCheck.url) service.healthCheck.url = service.base;
+            let routes = service.routes;
+            if (!routes || 0 === routes.length) {
+                routes = [];
+                if (service.host) routes.push({
+                    type: 'host',
+                    value: service.host,
+                    target: service.base
+                });
+                if (service.port) routes.push({
+                    type: 'port',
+                    value: service.port,
+                    target: service.base
+                });
+                if (0 === routes.length) routes.push({
+                    type: 'host',
+                    value: key,
+                    target: service.base
+                });
+                service.routes = routes;
+            }
+            for (const route of routes)if (!route.target) throw new Error(`服务 [${service.name}] 的路由配置缺少 target 字段`);
+            for (const route of routes)if ('port' === route.type) {
+                const port = route.value;
+                if (port === mainPort) throw new Error(`服务 [${service.name}] 的路由端口 ${port} 与主端口冲突`);
+                const adminApiPort = config.adminApi?.enabled ? config.adminApi.port : void 0;
+                if (adminApiPort && port === adminApiPort) throw new Error(`服务 [${service.name}] 的路由端口 ${port} 与管理 API 端口冲突`);
+                const existingService = portMap.get(port);
+                if (existingService) throw new Error(`端口冲突: 服务 [${service.name}] 和 [${existingService}] 都配置了端口 ${port}`);
+                portMap.set(port, service.name);
+            } else if ('host' === route.type) {
+                const hostname = route.value;
+                const existingService = hostnameMap.get(hostname);
+                if (existingService && existingService !== service.name) throw new Error(`Hostname 冲突: 服务 [${service.name}] 和 [${existingService}] 都配置了 hostname ${hostname}`);
+                hostnameMap.set(hostname, service.name);
+            }
         }
         return config;
     }
@@ -3323,6 +4120,20 @@ var __webpack_exports__ = {};
                 msg: 'DynaPM 网关已启动',
                 port: config.port || 3000
             });
+            const cleanup = async (signal)=>{
+                logger.info({
+                    msg: `⚠️ 收到 ${signal} 信号，正在清理...`
+                });
+                await gateway.cleanup();
+                process.exit(0);
+            };
+            process.on('SIGINT', ()=>cleanup('SIGINT'));
+            process.on('SIGTERM', ()=>cleanup('SIGTERM'));
+            process.on('exit', ()=>{
+                logger.info({
+                    msg: '👋 DynaPM 网关已退出'
+                });
+            });
         } catch (error) {
             logger.error({
                 msg: '启动失败',