@feng3d/cts 0.0.9 → 0.0.11

package/dist/handlers/unified-proxy.js

@@ -1,82 +1,86 @@
 /**
  * @module unified-proxy
- * @description 统一代理处理器模块，在指定端口上同时支持 HTTP 和 WebSocket 代理。
- * 将外部 HTTP/WebSocket 请求转发给穿透客户端，实现双向数据转发。
+ *
+ * 统一代理处理器模块。
+ *
+ * 在指定端口上同时支持 HTTP、WebSocket、TCP 和 UDP 代理。
+ * 所有 TCP 类协议（HTTP/WS/TCP）作为原始字节流转发，不做协议解析，
+ * HTTP 协议由外部客户端和本地服务端到端处理。
+ * UDP 使用基于会话的转发，30 秒超时自动清理。
  */
-import { Server as HttpServer } from 'http';
-import { WebSocket, WebSocketServer } from 'ws';
+import { createServer } from 'net';
+import { createSocket as createUdpSocket } from 'dgram';
+import { WebSocket } from 'ws';
 import { v4 as uuidv4 } from 'uuid';
 import { MessageType, createMessage, logger } from '@feng3d/chuantou-shared';
+/** UDP 会话超时时间（毫秒） */
+const UDP_SESSION_TIMEOUT = 30000;
 /**
  * 统一代理处理器
  *
- * 管理多个代理服务器实例，每个代理监听一个独立端口，
- * 同时支持 HTTP 请求和 WebSocket 升级请求。
- * 当外部请求到达代理端口时，将请求信息通过控制通道转发给对应的穿透客户端。
+ * 管理多个代理服务器实例，每个实例监听一个独立端口，
+ * 同时支持 TCP 类协议和 UDP 协议。
+ * 数据通过独立的二进制数据通道传输，不经过 WebSocket 控制通道。
  */
 export class UnifiedProxyHandler {
-    /**
-     * 创建统一代理处理器实例
-     *
-     * @param sessionManager - 会话管理器，用于获取客户端连接和管理连接记录
-     */
-    constructor(sessionManager) {
-        /**
-         * 待处理响应映射表
-         *
-         * 存储等待客户端响应的 Promise 回调和超时定时器，键为连接 ID。
-         */
-        this.pendingResponses = new Map();
-        /**
-         * 用户 WebSocket 连接映射表
-         *
-         * 存储外部用户的 WebSocket 连接，键为连接 ID，值为用户的 WebSocket 实例。
-         */
-        this.userConnections = new Map();
-        /**
-         * 流式 HTTP 响应映射表
-         *
-         * 存储正在进行的流式响应（如 SSE）的响应对象。
-         */
-        this.streamingResponses = new Map();
-        this.sessionManager = sessionManager;
+    constructor(sessionManager, dataChannelManager) {
         this.proxies = new Map();
-        this.wsServers = new Map();
+        /** 外部 TCP 连接映射表：connectionId → Socket */
+        this.userSockets = new Map();
+        /** UDP 会话映射表：sessionKey (addr:port) → UdpSession */
+        this.udpSessions = new Map();
+        /** connectionId → UDP 会话 key，用于反向查找 */
+        this.udpConnectionToSession = new Map();
+        this.sessionManager = sessionManager;
+        this.dataChannelManager = dataChannelManager;
+        // 监听来自客户端的 TCP 数据帧
+        this.dataChannelManager.on('data', (_clientId, connectionId, data) => {
+            this.handleDataFromClient(connectionId, data);
+        });
+        // 监听来自客户端的 UDP 数据帧
+        this.dataChannelManager.on('udpData', (_clientId, connectionId, data) => {
+            this.handleUdpDataFromClient(connectionId, data);
+        });
     }
     /**
      * 启动代理服务器
      *
-     * 在指定端口创建并启动一个 HTTP 服务器，该端口同时支持 HTTP 请求和 WebSocket 升级。
-     * 若该端口已存在代理或端口被占用，将抛出异常。
-     *
-     * @param port - 代理监听的端口号
-     * @param clientId - 绑定的客户端唯一标识 ID
-     * @returns 代理服务器启动完成的 Promise
-     * @throws 端口已存在代理或端口被占用时抛出错误
+     * 在指定端口创建 TCP 服务器和 UDP socket，同时支持所有协议。
      */
     async startProxy(port, clientId) {
         if (this.proxies.has(port)) {
             throw new Error(`端口 ${port} 的代理已存在`);
         }
-        const server = new HttpServer();
-        // 处理 HTTP 请求
-        server.on('request', async (req, res) => {
-            await this.handleHttpRequest(clientId, req, res);
+        const tcpServer = createServer({ pauseOnConnect: true });
+        const udpSocket = createUdpSocket('udp4');
+        // TCP 连接处理
+        tcpServer.on('connection', (socket) => {
+            this.handleNewTcpConnection(clientId, port, socket);
+        });
+        tcpServer.on('error', (error) => {
+            logger.error(`代理在端口 ${port} 上 TCP 错误:`, error);
         });
-        // 处理 WebSocket 升级请求
-        server.on('upgrade', async (req, socket, head) => {
-            await this.handleWebSocketUpgrade(clientId, req, socket, head);
+        // UDP 消息处理
+        udpSocket.on('message', (msg, rinfo) => {
+            this.handleUdpMessage(clientId, port, msg, rinfo);
         });
-        server.on('error', (error) => {
-            logger.error(`代理在端口 ${port} 上发生错误:`, error);
+        udpSocket.on('error', (error) => {
+            logger.error(`代理在端口 ${port} 上 UDP 错误:`, error);
         });
         return new Promise((resolve, reject) => {
-            server.listen(port, () => {
-                logger.log(`代理正在端口 ${port} 上监听（HTTP + WebSocket），绑定客户端 ${clientId}`);
-                this.proxies.set(port, server);
-                resolve();
+            tcpServer.listen(port, () => {
+                const actualPort = tcpServer.address().port;
+                udpSocket.bind(actualPort, () => {
+                    logger.log(`代理正在端口 ${actualPort} 上监听（TCP + UDP），绑定客户端 ${clientId}`);
+                    this.proxies.set(actualPort, { tcpServer, udpSocket, port: actualPort });
+                    resolve();
+                });
+                udpSocket.on('error', (error) => {
+                    tcpServer.close();
+                    reject(error);
+                });
             });
-            server.on('error', (error) => {
+            tcpServer.on('error', (error) => {
                 if (error.code === 'EADDRINUSE') {
                     reject(new Error(`端口 ${port} 已被占用`));
                 }
@@ -87,374 +91,238 @@ export class UnifiedProxyHandler {
         });
     }
     /**
-     * 处理外部 HTTP 请求
+     * 处理新的 TCP 连接
      *
-     * 将外部 HTTP 请求封装为消息发送给穿透客户端，等待客户端处理后返回响应。
-     * 支持流式响应（如 SSE）和普通 HTTP 响应。
-     *
-     * @param clientId - 处理该请求的客户端唯一标识 ID
-     * @param req - 收到的 HTTP 请求对象
-     * @param res - 用于发送响应的 HTTP 响应对象
+     * 读取首字节检测协议类型（仅用于日志），然后建立字节管道。
      */
-    async handleHttpRequest(clientId, req, res) {
+    handleNewTcpConnection(clientId, port, socket) {
         const connectionId = uuidv4();
         const clientSocket = this.sessionManager.getClientSocket(clientId);
+        const remoteAddress = socket.remoteAddress || '';
         if (!clientSocket || clientSocket.readyState !== WebSocket.OPEN) {
-            res.writeHead(502, { 'Content-Type': 'text/plain; charset=utf-8' });
-            res.end('网关错误：客户端未连接');
+            socket.destroy();
             return;
         }
-        // 记录连接
-        this.sessionManager.addConnection(clientId, connectionId, req.socket.remoteAddress || '', 'http');
-        logger.log(`HTTP 请求: ${req.method} ${req.url} -> 客户端 ${clientId} (${connectionId})`);
-        try {
-            // 构建请求头
-            const headers = {};
-            for (const [key, value] of Object.entries(req.headers)) {
-                if (value !== undefined) {
-                    headers[key] = Array.isArray(value) ? value.join(', ') : value;
-                }
-            }
-            // 读取请求体
-            let body;
-            if (req.method !== 'GET' && req.method !== 'HEAD') {
-                body = await this.readRequestBody(req);
-            }
-            // 发送新连接消息给客户端
-            const newConnMsg = createMessage(MessageType.NEW_CONNECTION, {
-                connectionId,
-                protocol: 'http',
-                method: req.method,
-                url: req.url || '/',
-                headers,
-                body: body?.toString('base64'),
-            });
-            clientSocket.send(JSON.stringify(newConnMsg));
-            // 等待客户端响应头（第一个消息）
-            const firstResponse = await this.waitForResponse(connectionId, clientId);
-            // 检查是否为流式响应（仅根据 Content-Type 判断）
-            const contentType = String(firstResponse.headers['content-type'] || '').toLowerCase();
-            const isStreaming = contentType.includes('text/event-stream') ||
-                contentType.includes('stream');
-            if (isStreaming) {
-                // 流式响应模式（SSE）
-                logger.log(`HTTP 流式响应: ${req.url} (${connectionId})`);
-                this.streamingResponses.set(connectionId, res);
-                // 发送响应头
-                res.writeHead(firstResponse.statusCode, firstResponse.headers);
-                res.flushHeaders();
-                // 如果有初始 body，先发送
-                if (firstResponse.body) {
-                    const bodyBuffer = Buffer.isBuffer(firstResponse.body)
-                        ? firstResponse.body
-                        : Buffer.from(firstResponse.body, 'base64');
-                    res.write(bodyBuffer);
-                }
-                // 等待流结束，不清理连接（由流结束事件处理）
-                this.pendingResponses.delete(connectionId);
-            }
-            else {
-                // 普通 HTTP 响应模式
-                res.writeHead(firstResponse.statusCode, firstResponse.headers);
-                if (firstResponse.body) {
-                    const bodyBuffer = Buffer.isBuffer(firstResponse.body)
-                        ? firstResponse.body
-                        : Buffer.from(firstResponse.body, 'base64');
-                    res.end(bodyBuffer);
-                }
-                else {
-                    res.end();
-                }
-                logger.log(`HTTP 响应: ${firstResponse.statusCode}，连接 ${connectionId}`);
-                // 清理连接
-                this.sessionManager.removeConnection(connectionId);
-                this.pendingResponses.delete(connectionId);
-            }
-        }
-        catch (error) {
-            logger.error(`处理 HTTP 请求 ${connectionId} 时出错:`, error);
-            if (!res.headersSent) {
-                res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
-                res.end('服务器内部错误');
+        // 存储外部连接
+        this.userSockets.set(connectionId, socket);
+        // 恢复 socket，读取首字节检测协议
+        socket.once('readable', () => {
+            const data = socket.read(Math.min(socket.readableLength || 1024, 1024));
+            if (!data) {
+                socket.once('data', (firstData) => {
+                    const protocol = this.detectProtocol(firstData);
+                    this.setupConnection(clientId, port, connectionId, socket, remoteAddress, protocol, firstData);
+                });
+                socket.resume();
+                return;
             }
-            // 清理连接
-            this.sessionManager.removeConnection(connectionId);
-            this.pendingResponses.delete(connectionId);
-            this.streamingResponses.delete(connectionId);
-        }
+            const protocol = this.detectProtocol(data);
+            this.setupConnection(clientId, port, connectionId, socket, remoteAddress, protocol, data);
+        });
     }
     /**
-     * 处理 WebSocket 升级请求
-     *
-     * 将外部 WebSocket 连接桥接到穿透客户端，实现双向实时数据转发。
-     *
-     * @param clientId - 处理该连接的客户端唯一标识 ID
-     * @param req - HTTP 升级请求对象
-     * @param socket - 底层 socket 连接
-     * @param head - 升级请求的头部 buffer
+     * 建立连接：发送 NEW_CONNECTION 通知，并设置双向数据管道
      */
-    async handleWebSocketUpgrade(clientId, req, socket, head) {
-        const connectionId = uuidv4();
+    setupConnection(clientId, port, connectionId, socket, remoteAddress, protocol, initialData) {
         const clientSocket = this.sessionManager.getClientSocket(clientId);
         if (!clientSocket || clientSocket.readyState !== WebSocket.OPEN) {
-            socket.write('HTTP/1.1 502 Bad Gateway\r\n\r\n');
             socket.destroy();
+            this.userSockets.delete(connectionId);
             return;
         }
         // 记录连接
-        this.sessionManager.addConnection(clientId, connectionId, req.socket.remoteAddress || '', 'websocket');
-        logger.log(`WebSocket 升级: ${req.url} -> 客户端 ${clientId} (${connectionId})`);
-        // 构建 WebSocket 服务器处理此连接
-        const wsServer = new WebSocketServer({ noServer: true });
-        wsServer.handleUpgrade(req, socket, head, (ws) => {
-            this.handleWebSocketConnection(clientId, connectionId, ws, req);
-        });
-    }
-    /**
-     * 处理 WebSocket 连接
-     *
-     * 当外部用户连接到代理端口时，记录连接信息，通知穿透客户端有新连接到来，
-     * 并设置消息转发、关闭和错误的事件处理。
-     *
-     * @param clientId - 处理该连接的客户端唯一标识 ID
-     * @param connectionId - 连接唯一标识 ID
-     * @param userWs - 外部用户的 WebSocket 连接
-     * @param req - HTTP 升级请求对象
-     */
-    handleWebSocketConnection(clientId, connectionId, userWs, req) {
-        const clientSocket = this.sessionManager.getClientSocket(clientId);
-        if (!clientSocket || clientSocket.readyState !== WebSocket.OPEN) {
-            userWs.close(1011, '客户端未连接');
-            return;
-        }
-        logger.log(`WebSocket 连接已建立: ${req.url} (${connectionId})`);
-        // 存储用户 WebSocket 引用
-        this.userConnections.set(connectionId, userWs);
-        // 构建请求头
-        const headers = {};
-        for (const [key, value] of Object.entries(req.headers)) {
-            if (value !== undefined) {
-                headers[key] = Array.isArray(value) ? value.join(', ') : value;
-            }
-        }
-        // 发送新连接消息给客户端
+        this.sessionManager.addConnection(clientId, connectionId, remoteAddress, protocol);
+        logger.log(`${protocol.toUpperCase()} 连接: ${remoteAddress} -> :${port} (${connectionId})`);
+        // 通过 WebSocket 控制通道发送 NEW_CONNECTION
         const newConnMsg = createMessage(MessageType.NEW_CONNECTION, {
             connectionId,
-            protocol: 'websocket',
-            url: req.url || '/',
-            wsHeaders: headers,
+            protocol,
+            remotePort: port,
+            remoteAddress,
         });
         clientSocket.send(JSON.stringify(newConnMsg));
-        // 处理来自用户的消息
-        userWs.on('message', (data) => {
-            this.forwardToClient(clientId, connectionId, data);
+        // 恢复 socket
+        socket.resume();
+        // 通过数据通道发送初始数据
+        this.dataChannelManager.sendToClient(clientId, connectionId, initialData);
+        // 后续数据通过数据通道转发
+        socket.on('data', (data) => {
+            this.dataChannelManager.sendToClient(clientId, connectionId, data);
         });
-        // 处理来自用户关闭
-        userWs.on('close', (code, reason) => {
-            logger.log(`用户 WebSocket 已关闭: ${connectionId} (${code})`);
-            this.notifyClientClose(clientId, connectionId, code);
+        socket.on('close', () => {
+            logger.log(`连接关闭: ${connectionId}`);
+            this.notifyClientClose(clientId, connectionId);
             this.cleanupConnection(connectionId);
         });
-        // 处理错误
-        userWs.on('error', (error) => {
-            logger.error(`用户 WebSocket 错误 ${connectionId}:`, error);
+        socket.on('error', (error) => {
+            logger.error(`连接错误 ${connectionId}:`, error.message);
             this.cleanupConnection(connectionId);
         });
     }
     /**
-     * 将用户消息转发到穿透客户端
-     *
-     * 将外部用户发送的 WebSocket 数据编码为 Base64 后，通过控制通道发送给穿透客户端。
-     *
-     * @param clientId - 目标客户端唯一标识 ID
-     * @param connectionId - 连接唯一标识 ID
-     * @param data - 用户发送的原始数据
+     * 检测连接协议类型（仅用于日志和统计）
      */
-    forwardToClient(clientId, connectionId, data) {
-        const clientSocket = this.sessionManager.getClientSocket(clientId);
-        if (clientSocket && clientSocket.readyState === WebSocket.OPEN) {
-            clientSocket.send(JSON.stringify({
-                type: 'connection_data',
-                connectionId,
-                data: data.toString('base64'),
-            }));
+    detectProtocol(data) {
+        if (data.length < 4)
+            return 'tcp';
+        const header = data.toString('ascii', 0, Math.min(data.length, 8)).toUpperCase();
+        const httpMethods = ['GET', 'POST', 'PUT', 'DELET', 'HEAD', 'OPTIO', 'PATCH', 'TRACE', 'CONN'];
+        for (const method of httpMethods) {
+            if (header.startsWith(method)) {
+                // 进一步检测是否为 WebSocket 升级请求
+                const fullHeader = data.toString('ascii', 0, Math.min(data.length, 512)).toLowerCase();
+                if (fullHeader.includes('upgrade: websocket')) {
+                    return 'websocket';
+                }
+                return 'http';
+            }
         }
+        return 'tcp';
     }
     /**
-     * 通知穿透客户端连接已关闭
+     * 处理来自客户端的 TCP 数据（通过数据通道）
      *
-     * 当外部用户的 WebSocket 连接关闭时，向穿透客户端发送连接关闭通知消息。
-     *
-     * @param clientId - 目标客户端唯一标识 ID
-     * @param connectionId - 已关闭的连接唯一标识 ID
-     * @param code - WebSocket 关闭状态码
+     * 写入到对应的外部 socket。
      */
-    notifyClientClose(clientId, connectionId, code) {
-        const clientSocket = this.sessionManager.getClientSocket(clientId);
-        if (clientSocket && clientSocket.readyState === WebSocket.OPEN) {
-            const closeMsg = createMessage(MessageType.CONNECTION_CLOSE, {
-                connectionId,
-            });
-            clientSocket.send(JSON.stringify(closeMsg));
+    handleDataFromClient(connectionId, data) {
+        const socket = this.userSockets.get(connectionId);
+        if (socket && !socket.destroyed) {
+            socket.write(data);
         }
     }
     /**
-     * 等待客户端响应
-     *
-     * 创建一个 Promise，等待穿透客户端处理完请求并返回响应数据。
-     * 若超过 30 秒未收到响应，将自动超时并拒绝 Promise。
-     *
-     * @param connectionId - 连接唯一标识 ID
-     * @param clientId - 客户端唯一标识 ID
-     * @returns 客户端返回的 HTTP 响应数据
-     */
-    waitForResponse(connectionId, clientId) {
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.pendingResponses.delete(connectionId);
-                reject(new Error('响应超时'));
-            }, 30000); // 30秒超时
-            this.pendingResponses.set(connectionId, { resolve, reject, timeout });
-        });
-    }
-    /**
-     * 读取 HTTP 请求体
-     *
-     * 从 IncomingMessage 流中读取完整的请求体数据。
-     *
-     * @param req - HTTP 请求对象
-     * @returns 包含完整请求体的 Buffer
+     * 处理外部 UDP 消息
      */
-    readRequestBody(req) {
-        return new Promise((resolve, reject) => {
-            const chunks = [];
-            req.on('data', (chunk) => {
-                chunks.push(chunk);
-            });
-            req.on('end', () => {
-                resolve(Buffer.concat(chunks));
+    handleUdpMessage(clientId, port, msg, rinfo) {
+        const sessionKey = `${rinfo.address}:${rinfo.port}`;
+        let session = this.udpSessions.get(sessionKey);
+        if (session) {
+            // 已有会话，刷新超时
+            clearTimeout(session.timer);
+            session.timer = setTimeout(() => this.cleanupUdpSession(sessionKey), UDP_SESSION_TIMEOUT);
+            // 转发数据到客户端
+            this.dataChannelManager.sendUdpToClient(clientId, session.connectionId, msg);
+        }
+        else {
+            // 新会话
+            const clientSocket = this.sessionManager.getClientSocket(clientId);
+            if (!clientSocket || clientSocket.readyState !== WebSocket.OPEN) {
+                return;
+            }
+            const connectionId = uuidv4();
+            session = {
+                connectionId,
+                address: rinfo.address,
+                port: rinfo.port,
+                timer: setTimeout(() => this.cleanupUdpSession(sessionKey), UDP_SESSION_TIMEOUT),
+            };
+            this.udpSessions.set(sessionKey, session);
+            this.udpConnectionToSession.set(connectionId, { port, sessionKey });
+            // 记录连接
+            this.sessionManager.addConnection(clientId, connectionId, rinfo.address, 'udp');
+            logger.log(`UDP 会话: ${rinfo.address}:${rinfo.port} -> :${port} (${connectionId})`);
+            // 通过 WebSocket 发送 NEW_CONNECTION
+            const newConnMsg = createMessage(MessageType.NEW_CONNECTION, {
+                connectionId,
+                protocol: 'udp',
+                remotePort: port,
+                remoteAddress: rinfo.address,
             });
-            req.on('error', reject);
-        });
+            clientSocket.send(JSON.stringify(newConnMsg));
+            // 通过 UDP 数据通道转发初始数据
+            this.dataChannelManager.sendUdpToClient(clientId, connectionId, msg);
+        }
     }
     /**
-     * 处理穿透客户端返回的响应数据
+     * 处理来自客户端的 UDP 数据（通过 UDP 数据通道）
      *
-     * 接收客户端处理完请求后返回的 HTTP 响应数据，清除超时定时器并解析对应的待处理 Promise。
-     *
-     * @param connectionId - 连接唯一标识 ID
-     * @param data - 客户端返回的原始响应消息对象，包含 statusCode, headers, body 等字段
+     * 回发给外部 UDP 客户端。
      */
-    handleClientResponse(connectionId, data) {
-        const pending = this.pendingResponses.get(connectionId);
-        if (pending) {
-            clearTimeout(pending.timeout);
-            this.pendingResponses.delete(connectionId);
-            // 提取需要的响应字段
-            const responseData = {
-                statusCode: data.statusCode || 200,
-                headers: data.headers || {},
-                body: data.body,
-            };
-            pending.resolve(responseData);
-        }
+    handleUdpDataFromClient(connectionId, data) {
+        const sessionInfo = this.udpConnectionToSession.get(connectionId);
+        if (!sessionInfo)
+            return;
+        const session = this.udpSessions.get(sessionInfo.sessionKey);
+        if (!session)
+            return;
+        const proxy = this.proxies.get(sessionInfo.port);
+        if (!proxy)
+            return;
+        proxy.udpSocket.send(data, session.port, session.address);
     }
     /**
-     * 处理来自穿透客户端的数据
-     *
-     * 将穿透客户端发送的数据转发给对应的外部用户 WebSocket 连接。
-     *
-     * @param connectionId - 连接唯一标识 ID
-     * @param data - 穿透客户端发送的数据
+     * 通知客户端连接已关闭
      */
-    handleClientData(connectionId, data) {
-        const userWs = this.userConnections.get(connectionId);
-        if (userWs && userWs.readyState === WebSocket.OPEN) {
-            userWs.send(data);
+    notifyClientClose(clientId, connectionId) {
+        const clientSocket = this.sessionManager.getClientSocket(clientId);
+        if (clientSocket && clientSocket.readyState === WebSocket.OPEN) {
+            const closeMsg = createMessage(MessageType.CONNECTION_CLOSE, {
+                connectionId,
+            });
+            clientSocket.send(JSON.stringify(closeMsg));
         }
     }
     /**
-     * 处理来自穿透客户端的关闭请求
-     *
-     * 当穿透客户端请求关闭某个连接时，关闭对应的外部用户 WebSocket 连接并清理资源。
-     *
-     * @param connectionId - 需要关闭的连接唯一标识 ID
-     * @param code - 可选的 WebSocket 关闭状态码，默认为 1000（正常关闭）
+     * 处理来自客户端的关闭请求
      */
-    handleClientClose(connectionId, code) {
-        const userWs = this.userConnections.get(connectionId);
-        if (userWs) {
-            userWs.close(code || 1000);
+    handleClientClose(connectionId) {
+        // TCP 连接
+        const socket = this.userSockets.get(connectionId);
+        if (socket) {
+            socket.destroy();
+            this.cleanupConnection(connectionId);
+            return;
+        }
+        // UDP 会话
+        const sessionInfo = this.udpConnectionToSession.get(connectionId);
+        if (sessionInfo) {
+            this.cleanupUdpSession(sessionInfo.sessionKey);
         }
-        this.cleanupConnection(connectionId);
     }
-    /**
-     * 清理连接资源
-     *
-     * 从用户连接映射表和会话管理器中移除指定连接的记录。
-     *
-     * @param connectionId - 需要清理的连接唯一标识 ID
-     */
     cleanupConnection(connectionId) {
-        this.userConnections.delete(connectionId);
-        this.streamingResponses.delete(connectionId);
+        this.userSockets.delete(connectionId);
         this.sessionManager.removeConnection(connectionId);
     }
-    /**
-     * 处理来自客户端的流式响应数据
-     *
-     * 将客户端发送的流式数据（如 SSE 事件）转发给对应的外部 HTTP 连接。
-     *
-     * @param connectionId - 连接唯一标识 ID
-     * @param data - 客户端发送的流式数据
-     */
-    handleClientStreamData(connectionId, data) {
-        const res = this.streamingResponses.get(connectionId);
-        if (res && !res.writableEnded) {
-            res.write(data);
-        }
-    }
-    /**
-     * 处理来自客户端的流式响应结束通知
-     *
-     * 当客户端通知流式响应结束时，关闭外部 HTTP 连接并清理资源。
-     *
-     * @param connectionId - 连接唯一标识 ID
-     */
-    handleClientStreamEnd(connectionId) {
-        const res = this.streamingResponses.get(connectionId);
-        if (res && !res.writableEnded) {
-            res.end();
+    cleanupUdpSession(sessionKey) {
+        const session = this.udpSessions.get(sessionKey);
+        if (session) {
+            clearTimeout(session.timer);
+            this.udpConnectionToSession.delete(session.connectionId);
+            this.sessionManager.removeConnection(session.connectionId);
         }
-        logger.log(`流式响应结束: ${connectionId}`);
-        this.cleanupConnection(connectionId);
+        this.udpSessions.delete(sessionKey);
     }
     /**
      * 停止指定端口的代理服务器
-     *
-     * 关闭指定端口上的代理服务器并从映射表中移除。
-     *
-     * @param port - 需要停止的代理端口号
-     * @returns 代理服务器关闭完成的 Promise
      */
     async stopProxy(port) {
-        const server = this.proxies.get(port);
-        if (server) {
-            return new Promise((resolve) => {
-                server.close(() => {
+        const proxy = this.proxies.get(port);
+        if (!proxy)
+            return;
+        // 清理该端口的所有 TCP 连接
+        for (const [connId, socket] of this.userSockets) {
+            socket.destroy();
+            this.userSockets.delete(connId);
+        }
+        // 清理该端口的所有 UDP 会话
+        for (const [key, session] of this.udpSessions) {
+            const info = this.udpConnectionToSession.get(session.connectionId);
+            if (info && info.port === port) {
+                this.cleanupUdpSession(key);
+            }
+        }
+        return new Promise((resolve) => {
+            proxy.udpSocket.close(() => {
+                proxy.tcpServer.close(() => {
                     logger.log(`代理已在端口 ${port} 上停止`);
                     this.proxies.delete(port);
                     resolve();
                 });
             });
-        }
+        });
     }
     /**
      * 停止所有代理服务器
-     *
-     * 并行关闭所有已启动的代理服务器。
-     *
-     * @returns 所有代理服务器关闭完成的 Promise
      */
     async stopAll() {
         const stopPromises = [];
@@ -465,8 +333,6 @@ export class UnifiedProxyHandler {
     }
     /**
      * 获取所有活跃代理的端口列表
-     *
-     * @returns 当前正在运行的所有代理端口号数组
      */
     getActivePorts() {
         return Array.from(this.proxies.keys());