@cjwddz/mirror 2.0.9 → 2.0.11

package/README.md

@@ -1,15 +1,6 @@
-# Mirror - HTTP 隧道工具
+# Mirror
 
-将本地服务暴露到公网，支持多服务代理。
-
-## 特性
-
-- ✅ 支持多个本地服务同时代理
-- ✅ 基于路径长度的优先级匹配（路径越长优先级越高）
-- ✅ 规则持久化存储
-- ✅ Token 认证
-- ✅ 单客户端连接（新连接自动踢出旧连接）
-- ✅ 支持 WebSocket 协议
+HTTP 隧道：把本地服务通过公网服务端暴露出去，支持多域名/多路径规则。
 
 ## 安装
 
@@ -17,255 +8,46 @@
 npm install -g @cjwddz/mirror
 ```
 
-## 快速开始
-
-### 1. 启动服务端
+## 使用
 
-在公网服务器上运行：
+**服务端**（公网机器）：
 
 ```bash
 mirror server -p 80 -t 3000 --token your-token
 ```
 
-参数说明：
-
-- `-p, --port`: HTTP 服务端口（默认 80）
-- `-t, --tunnel-port`: WebSocket 隧道端口（默认 3000，通常由 Nginx 反向代理到 443）
-- `--host`: 监听地址（默认 0.0.0.0）
-- `--token`: 认证令牌（可选）
-
-### 2. 添加代理规则
-
-在本地机器上添加规则：
-
-```bash
-# 添加 API 规则（路径较长，优先级高）
-mirror add example.com/api localhost:3001
-
-# 添加用户 API 规则（路径最长，优先级最高）
-mirror add example.com/api/users localhost:3002
-
-# 添加前端规则（根路径，优先级低）
-mirror add example.com localhost:5173
-```
-
-### 3. 连接服务端
+**客户端**（本机）：
 
 ```bash
+# 连接
 mirror link mirror.tri-bank.online --token your-token
-```
-
-连接后，规则会自动同步到服务端。
-
-### 4. 查看状态
-
-```bash
-mirror status
-```
 
-输出示例：
+# 添加规则（域名+路径 -> 本地地址）
+mirror add example.com/api    localhost:3001
+mirror add example.com        localhost:5173
+# 支持写 https://domain/path，协议会被忽略
+mirror add https://test1.example.com/foo/ 127.0.0.1:8082
 
-```
-Mirror - Connection Status
-==========================
-
-✓ Mirror client is running
-    PID: 12345
-
-Server Configuration:
-    Server: mirror.tri-bank.online
-    Token: your-toke...
-
-Proxy Rules (3 configured):
-    [3] example.com/api/users -> localhost:3002 (高)
-    [1] example.com/api -> localhost:3001 (高)
-    [2] example.com/ -> localhost:5173 (低)
-```
-
-### 5. 查看规则
-
-```bash
+# 查看 / 删除规则
 mirror list
-```
-
-输出示例：
-
-```
-Mirror - Proxy Rules
-====================
-
-Total: 3 rule(s)
-
-[3] example.com/api/users -> localhost:3002
-     Priority: 高（路径规则）
-     Created: 2/18/2026, 11:57:20 AM
-
-[1] example.com/api -> localhost:3001
-     Priority: 高（路径规则）
-     Created: 2/18/2026, 11:57:14 AM
-
-[2] example.com/ -> localhost:5173
-     Priority: 低（域名规则）
-     Created: 2/18/2026, 11:57:17 AM
-```
-
-### 6. 删除规则
-
-```bash
-# 删除指定规则
-mirror remove 1
-
-# 删除所有规则
-mirror remove
-```
-
-### 7. 断开连接
-
-```bash
-mirror stop
-```
-
-## 命令参考
-
-### `mirror link <server> [options]`
-
-连接到 Mirror 服务端。
-
-- `server`: 服务端地址（如 `mirror.tri-bank.online`）
-- `-t, --token`: 认证令牌
-
-### `mirror add <domain/path> <target>`
-
-添加代理规则。
-
-- `domain/path`: 域名和路径组合（如 `example.com/api`）
-- `target`: 目标服务地址（如 `localhost:3001`）
-
-**规则格式说明：**
-
-- 域名和路径写在一起，使用 `/` 分隔
-- 路径可以省略，省略时默认为 `/`
-- 示例：
-  - `example.com/api` - 匹配 `example.com/api` 开头的请求
-  - `example.com` 或 `example.com/` - 匹配 `example.com` 域名的所有请求
-
-### `mirror remove [ruleId]`
-
-删除代理规则。
-
-- `ruleId`: 规则 ID（可选，不指定则删除所有规则）
-
-### `mirror list`
-
-查看所有代理规则。
-
-### `mirror status`
-
-查看当前连接状态和配置。
-
-### `mirror stop`
-
-断开与服务端的连接。
-
-### `mirror sync`
-
-请求后台 link 进程将当前规则同步到服务端。若先执行了 `mirror add` / `mirror remove` 再在另一终端执行本命令，可手动触发一次同步（通常 add/remove 会自动写同步标记）。
-
-### `mirror server [options]`
-
-启动 HTTP 隧道服务端。
-
-- `-p, --port`: HTTP 服务端口（默认 80）
-- `-t, --tunnel-port`: WebSocket 隧道端口（默认 3000）
-- `--host`: 监听地址（默认 0.0.0.0）
-- `--token`: 认证令牌（可选）
-- `--timeout`: 请求超时时间（毫秒，默认 30000）
-
-## 规则匹配逻辑
-
-1. 规则按路径长度降序排序（路径越长优先级越高）
-2. 同长度的规则，后添加的优先级更高
-3. 路径规则：请求路径以规则路径开头即匹配
-4. 根路径规则（`/`）：匹配该域名的所有路径
-
-### 示例
-
-假设有以下规则：
+mirror remove 1    # 删单条
+mirror remove      # 删全部
 
+mirror status      # 连接状态
+mirror stop        # 断开
 ```
-[1] example.com/api -> localhost:3001 (路径长度: 4)
-[2] example.com/ -> localhost:5173 (路径长度: 1)
-[3] example.com/api/users -> localhost:3002 (路径长度: 10)
-```
-
-请求匹配结果（按优先级排序）：
-
-1. `example.com/api/users/v1` → `localhost:3002`（匹配规则 3，路径长度 10）
-2. `example.com/api/products` → `localhost:3001`（匹配规则 1，路径长度 4）
-3. `example.com/` → `localhost:5173`（匹配规则 2，路径长度 1）
-4. `example.com/about` → `localhost:5173`（匹配规则 2，路径长度 1）
-
-## 配置文件
-
-规则存储在 `~/.mirror/rules.json` 中：
-
-```json
-{
-  "server": "mirror.tri-bank.online",
-  "token": "your-token",
-  "rules": [
-    {
-      "id": 1,
-      "domain": "example.com",
-      "path": "/api",
-      "target": "localhost:3001",
-      "priority": "high",
-      "createdAt": "2026-02-18T03:50:18.627Z"
-    }
-  ]
-}
-```
-
-断开连接后规则会保留，下次连接时自动同步。
-
-## 进程管理
-
-Mirror 客户端使用锁文件机制确保同一时间只有一个实例在运行。锁文件位于 `~/.mirror/.lock`。
-
-- 如果尝试启动第二个实例，会提示已有进程在运行
-- 如果进程异常退出，锁文件会被自动清理
-- 使用 `mirror stop` 命令可以安全停止运行中的客户端
-
-## 故障排查
-
-### 配置了规则但通过 https://test1.xxx.com/ 无法访问
-
-常见原因：**访问代理域名（如 test1.tri-bank.online）的请求没有到达 Mirror 服务端的 HTTP 端口**。
-
-服务端有两个端口：
-
-- **HTTP 端口（默认 80）**：接收浏览器/客户端对代理域名的请求（如 `https://test1.tri-bank.online/`），按 Host 匹配规则并转发到你的本地服务。
-- **WebSocket 端口（默认 3000）**：仅用于客户端 `mirror link` 的隧道连接（如 `wss://mirror.tri-bank.online`）。
-
-因此 Nginx 需要区分配置：
-
-1. **mirror.tri-bank.online**（或你的隧道域名）→ 反向代理到服务端的 **3000** 端口（WebSocket）。
-2. **test1.tri-bank.online**（及所有要代理的子域名）→ 反向代理到服务端的 **80** 端口（HTTP）。
-
-若只配置了隧道域名指向 3000，而 test1 等域名未指向 80，则访问 test1 的请求不会进入 Mirror，就会出现“无法访问”。请在服务端 Nginx 中为 test1.tri-bank.online 增加 `server_name` 并 `proxy_pass http://127.0.0.1:80`（或你实际使用的 HTTP 端口）。参见仓库内 `nginx.example.conf` 中的「代理域名 → HTTP 80」示例。
 
-### 规则已添加但服务端仍返回 "No matching rule"
+## 规则匹配
 
-- 若在「先 link、后 add」的另一终端添加规则，后台 link 会在约 2 秒内自动同步；也可执行 `mirror sync` 手动触发同步。
-- 确认本机目标服务已启动：例如规则指向 `http://127.0.0.1:8081` 时，本地应能访问 `curl http://127.0.0.1:8081/`。
+- 规则按**路径长度**从长到短匹配，路径越长优先级越高。
+- `domain/path` 支持：`example.com/api`、`example.com`（等价于根路径 `/`）、或 `https://example.com/path`（协议会在解析时去掉）。
+- 规则存于 `~/.mirror/rules.json`，增删后下次请求即生效。
 
-## 注意事项
+## 常见问题
 
-- 服务端和客户端必须使用相同的 token（如果配置了）
-- 端口需要开放防火墙访问
-- 建议在生产环境使用 HTTPS
-- WebSocket 隧道使用 wss:// 协议，需要 SSL 证书
+- **访问代理域名 404**：确认 Nginx 里**代理域名**（如 test1.xxx.com）反代到服务端 **HTTP 端口（默认 80）**；**隧道域名**（mirror.xxx.com）反代到 **WebSocket 端口（默认 3000）**。
+- **匹配不到规则**：确认本机目标服务已启动，且 `mirror status` 中规则与预期一致。
 
-## 许可证
+## License
 
 MIT

package/dist/cli/index.js

@@ -89,7 +89,7 @@ program
     .option('-t, --tunnel-port <port>', 'WebSocket 隧道端口（默认 3000）', '3000')
     .option('--host <host>', '监听地址（默认 0.0.0.0）', '0.0.0.0')
     .option('--token <token>', '认证令牌（可选）')
-    .option('--timeout <ms>', '请求超时时间（毫秒）', '30000')
+    .option('--timeout <ms>', '请求超时时间（毫秒）', '60000')
     .action((options) => serverCommand({
     port: parseInt(options.port, 10),
     tunnelPort: parseInt(options.tunnelPort, 10),

package/dist/core/http-tunnel-client.d.ts

@@ -14,9 +14,6 @@ export interface HttpTunnelClientOptions {
     /** 可选：未提供 getTarget 时或 WS 升级时的默认目标 base URL */
     targetUrl?: string;
 }
-/**
- * HTTP 隧道客户端类
- */
 export declare class HttpTunnelClient {
     private targetUrl;
     private tunnelWs;
@@ -24,19 +21,25 @@ export declare class HttpTunnelClient {
     private httpAgent;
     private httpsAgent;
     private wsClients;
+    private pendingStreamRequests;
     constructor(options: HttpTunnelClientOptions);
     /**
-     * 处理隧道消息
+     * 处理隧道消息（支持二进制 body 帧与 JSON 控制消息）
      */
     private handleTunnelMessage;
+    private handleRequestBodyChunk;
+    private handleHttpRequestChunk;
+    private handleHttpRequestEnd;
     /** 目标未写协议时拼成完整 URL；默认 http（本机服务多为 HTTP，入口 HTTPS 由 Nginx 终结） */
     private normalizeTargetUrl;
     /**
-     * 处理 HTTP 请求
-     * 若消息无 target 且配置了 getTarget，则由客户端根据 Host/path 匹配规则得到目标。
-     * 目标未写协议时默认 http（本地服务通常为 HTTP）。
+     * 流式：处理 HTTP 请求开始（创建本地请求，不写 body，等 CHUNK/END）
+     */
+    private handleHttpRequestStart;
+    /**
+     * 创建流式 HTTP 请求：收到 response 后发送 START，再流式发送 body 帧与 END
      */
-    private handleHttpRequest;
+    private createStreamingHttpRequest;
     /**
      * 处理 WebSocket 升级请求；若有 getTarget 则按 Host/path 解析目标（与 HTTP 规则一致）
      */
@@ -49,10 +52,6 @@ export declare class HttpTunnelClient {
      * 处理 WebSocket 关闭消息
      */
     private handleWsClose;
-    /**
-     * 发送 HTTP 请求到本地服务
-     */
-    private sendHttpRequest;
     /**
      * 构建目标 URL
      */

package/dist/core/http-tunnel-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-tunnel-client.d.ts","sourceRoot":"","sources":["../../src/core/http-tunnel-client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAW/B;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,SAAS,CAAC;IACpB,yCAAyC;IACzC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAChE,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,SAAS,CAA+D;IAChF,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,SAAS,CAAqC;gBAE1C,OAAO,EAAE,uBAAuB;IAwC5C;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAwC3B,+DAA+D;IAC/D,OAAO,CAAC,kBAAkB;IAK1B;;;;OAIG;YACW,iBAAiB;IA0D/B;;OAEG;YACW,eAAe;IAiF7B;;OAEG;IACH,OAAO,CAAC,YAAY;IAWpB;;OAEG;IACH,OAAO,CAAC,aAAa;IASrB;;OAEG;IACH,OAAO,CAAC,eAAe;IA+DvB;;OAEG;IACH,OAAO,CAAC,cAAc;IAmCtB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;OAEG;IACH,OAAO,CAAC,MAAM;IASd;;OAEG;IACH,KAAK,IAAI,IAAI;CASd"}
+{"version":3,"file":"http-tunnel-client.d.ts","sourceRoot":"","sources":["../../src/core/http-tunnel-client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAoB/B;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,SAAS,CAAC;IACpB,yCAAyC;IACzC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAChE,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAUD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,QAAQ,CAAY;IAC5B,OAAO,CAAC,SAAS,CAA+D;IAChF,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,qBAAqB,CAAgD;gBAEjE,OAAO,EAAE,uBAAuB;IAwC5C;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoD3B,OAAO,CAAC,sBAAsB;IAO9B,OAAO,CAAC,sBAAsB;IAO9B,OAAO,CAAC,oBAAoB;IAQ5B,+DAA+D;IAC/D,OAAO,CAAC,kBAAkB;IAK1B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA+C9B;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAyElC;;OAEG;YACW,eAAe;IAiF7B;;OAEG;IACH,OAAO,CAAC,YAAY;IAWpB;;OAEG;IACH,OAAO,CAAC,aAAa;IASrB;;OAEG;IACH,OAAO,CAAC,cAAc;IAmCtB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;OAEG;IACH,OAAO,CAAC,MAAM;IASd;;OAEG;IACH,KAAK,IAAI,IAAI;CAQd"}

package/dist/core/http-tunnel-client.js

@@ -5,10 +5,7 @@
 import http from 'http';
 import https from 'https';
 import { WebSocket } from 'ws';
-import { isHttpTunnelMessage, } from './http-tunnel-protocol.js';
-/**
- * HTTP 隧道客户端类
- */
+import { isHttpTunnelMessage, decodeBodyChunkFrame, encodeBodyChunkFrame, isBodyChunkFrame, BODY_CHUNK_REQUEST, BODY_CHUNK_RESPONSE, } from './http-tunnel-protocol.js';
 export class HttpTunnelClient {
     targetUrl;
     tunnelWs;
@@ -16,6 +13,7 @@ export class HttpTunnelClient {
     httpAgent;
     httpsAgent;
     wsClients = new Map(); // requestId -> WebSocket client
+    pendingStreamRequests = new Map();
     constructor(options) {
         this.targetUrl = new URL(options.targetUrl ?? 'http://localhost');
         this.tunnelWs = options.tunnelWs;
@@ -51,11 +49,17 @@ export class HttpTunnelClient {
         });
     }
     /**
-     * 处理隧道消息
+     * 处理隧道消息（支持二进制 body 帧与 JSON 控制消息）
      */
     handleTunnelMessage(data) {
+        const buf = typeof data === 'string' ? Buffer.from(data, 'utf8') : data;
+        if (Buffer.isBuffer(buf) && buf.length >= 1 && isBodyChunkFrame(buf)) {
+            const decoded = decodeBodyChunkFrame(buf, BODY_CHUNK_REQUEST);
+            if (decoded)
+                this.handleRequestBodyChunk(decoded.requestId, decoded.payload);
+            return;
+        }
         try {
-            // 正确处理 Buffer 和 string 类型的数据
             const messageStr = typeof data === 'string' ? data : data.toString('utf8');
             const message = JSON.parse(messageStr);
             if (!isHttpTunnelMessage(message)) {
@@ -64,10 +68,15 @@ export class HttpTunnelClient {
             }
             switch (message.type) {
                 case 'WELCOME':
-                    // 忽略欢迎消息
                     break;
-                case 'HTTP_REQUEST':
-                    this.handleHttpRequest(message);
+                case 'HTTP_REQUEST_START':
+                    this.handleHttpRequestStart(message);
+                    break;
+                case 'HTTP_REQUEST_CHUNK':
+                    this.handleHttpRequestChunk(message);
+                    break;
+                case 'HTTP_REQUEST_END':
+                    this.handleHttpRequestEnd(message);
                     break;
                 case 'WS_UPGRADE':
                     this.handleWsUpgrade(message);
@@ -86,6 +95,25 @@ export class HttpTunnelClient {
             console.error('[HTTP Tunnel Client] Error handling tunnel message:', error);
         }
     }
+    handleRequestBodyChunk(requestId, payload) {
+        const pending = this.pendingStreamRequests.get(requestId);
+        if (pending?.req && !pending.req.destroyed) {
+            pending.req.write(payload);
+        }
+    }
+    handleHttpRequestChunk(message) {
+        const pending = this.pendingStreamRequests.get(message.requestId);
+        if (pending?.req && !pending.req.destroyed && message.data) {
+            pending.req.write(Buffer.from(message.data, 'base64'));
+        }
+    }
+    handleHttpRequestEnd(message) {
+        const pending = this.pendingStreamRequests.get(message.requestId);
+        if (pending?.req && !pending.req.destroyed) {
+            this.pendingStreamRequests.delete(message.requestId);
+            pending.req.end();
+        }
+    }
     /** 目标未写协议时拼成完整 URL；默认 http（本机服务多为 HTTP，入口 HTTPS 由 Nginx 终结） */
     normalizeTargetUrl(resolved) {
         if (resolved.startsWith('http://') || resolved.startsWith('https://'))
@@ -93,62 +121,106 @@ export class HttpTunnelClient {
         return `http://${resolved}`;
     }
     /**
-     * 处理 HTTP 请求
-     * 若消息无 target 且配置了 getTarget，则由客户端根据 Host/path 匹配规则得到目标。
-     * 目标未写协议时默认 http（本地服务通常为 HTTP）。
+     * 流式：处理 HTTP 请求开始（创建本地请求，不写 body，等 CHUNK/END）
      */
-    async handleHttpRequest(message) {
-        try {
-            const { requestId, method, url: requestUrl, headers, body, target } = message;
-            let targetUrlStr;
-            if (target) {
-                targetUrlStr = target.startsWith('http') ? target : `http://${target}`;
-            }
-            else if (this.getTarget) {
-                const host = headers?.host ?? '';
-                const domain = host.split(':')[0];
-                const pathname = new URL(requestUrl || '/', `http://${host}`).pathname;
-                const resolved = this.getTarget(domain, pathname);
-                if (resolved == null) {
-                    this.tunnelWs.send(JSON.stringify({
-                        type: 'HTTP_RESPONSE',
-                        requestId,
-                        statusCode: 404,
-                        statusMessage: 'Not Found',
-                        headers: { 'Content-Type': 'text/plain' },
-                        body: Buffer.from('No matching rule for this request').toString('base64'),
-                    }));
-                    return;
-                }
-                targetUrlStr = this.normalizeTargetUrl(resolved);
-            }
-            else {
-                targetUrlStr = this.buildTargetUrl(requestUrl);
+    handleHttpRequestStart(message) {
+        const { requestId, method, url: requestUrl, headers, target } = message;
+        let targetUrlStr;
+        if (target) {
+            targetUrlStr = target.startsWith('http') ? target : `http://${target}`;
+        }
+        else if (this.getTarget) {
+            const host = headers?.host ?? '';
+            const domain = host.split(':')[0];
+            const pathname = new URL(requestUrl || '/', `http://${host}`).pathname;
+            const resolved = this.getTarget(domain, pathname);
+            if (resolved == null) {
+                this.tunnelWs.send(JSON.stringify({
+                    type: 'HTTP_RESPONSE_START',
+                    requestId,
+                    statusCode: 404,
+                    statusMessage: 'Not Found',
+                    headers: { 'Content-Type': 'text/plain' },
+                }));
+                this.tunnelWs.send(JSON.stringify({ type: 'HTTP_RESPONSE_END', requestId }));
+                return;
             }
-            // 目标仅含 origin，需拼上原始请求路径与查询，再转发
-            const fullTargetUrl = new URL(requestUrl || '/', targetUrlStr).href;
-            const bodyBuffer = body ? Buffer.from(body, 'base64') : undefined;
-            const response = await this.sendHttpRequest(method, fullTargetUrl, headers, bodyBuffer);
-            const responseMessage = {
-                type: 'HTTP_RESPONSE',
-                requestId,
-                statusCode: response.statusCode,
-                statusMessage: response.statusMessage || 'OK',
-                headers: this.normalizeHeaders(response.headers),
-                body: response.body ? response.body.toString('base64') : undefined,
-            };
-            this.tunnelWs.send(JSON.stringify(responseMessage));
+            targetUrlStr = this.normalizeTargetUrl(resolved);
+        }
+        else {
+            targetUrlStr = this.buildTargetUrl(requestUrl);
+        }
+        const fullTargetUrl = new URL(requestUrl || '/', targetUrlStr).href;
+        try {
+            const req = this.createStreamingHttpRequest(requestId, method, fullTargetUrl, headers);
+            this.pendingStreamRequests.set(requestId, { req });
         }
         catch (error) {
-            console.error('[HTTP Tunnel Client] Error handling HTTP request:', error);
+            console.error('[HTTP Tunnel Client] Error creating HTTP request:', error);
             this.tunnelWs.send(JSON.stringify({
                 type: 'TUNNEL_ERROR',
-                requestId: message.requestId,
+                requestId,
                 error: error instanceof Error ? error.message : 'Unknown error',
                 code: 'REQUEST_ERROR',
             }));
         }
     }
+    /**
+     * 创建流式 HTTP 请求：收到 response 后发送 START，再流式发送 body 帧与 END
+     */
+    createStreamingHttpRequest(requestId, method, targetUrl, headers) {
+        const urlObj = new URL(targetUrl);
+        const isHttps = urlObj.protocol === 'https:';
+        const httpModule = isHttps ? https : http;
+        const forwardHeaders = { ...headers };
+        const forwardedProto = isHttps ? 'https' : 'http';
+        forwardHeaders['x-forwarded-proto'] = forwardedProto;
+        forwardHeaders['x-forwarded-scheme'] = forwardedProto;
+        const options = {
+            hostname: urlObj.hostname,
+            port: urlObj.port || (isHttps ? 443 : 80),
+            path: urlObj.pathname + urlObj.search,
+            method,
+            headers: forwardHeaders,
+            agent: isHttps ? this.httpsAgent : this.httpAgent,
+            rejectUnauthorized: false,
+        };
+        const req = httpModule.request(options, (res) => {
+            this.tunnelWs.send(JSON.stringify({
+                type: 'HTTP_RESPONSE_START',
+                requestId,
+                statusCode: res.statusCode || 200,
+                statusMessage: res.statusMessage || 'OK',
+                headers: this.normalizeHeaders(res.headers),
+            }));
+            res.on('data', (chunk) => {
+                const frame = encodeBodyChunkFrame(BODY_CHUNK_RESPONSE, requestId, chunk);
+                this.tunnelWs.send(frame);
+            });
+            res.on('end', () => {
+                this.tunnelWs.send(JSON.stringify({ type: 'HTTP_RESPONSE_END', requestId }));
+            });
+            res.on('error', (err) => {
+                console.error('[HTTP Tunnel Client] Response stream error:', err);
+                this.tunnelWs.send(JSON.stringify({
+                    type: 'TUNNEL_ERROR',
+                    requestId,
+                    error: err.message,
+                    code: 'RESPONSE_ERROR',
+                }));
+            });
+        });
+        req.on('error', (error) => {
+            this.pendingStreamRequests.delete(requestId);
+            this.tunnelWs.send(JSON.stringify({
+                type: 'TUNNEL_ERROR',
+                requestId,
+                error: error.message,
+                code: 'REQUEST_ERROR',
+            }));
+        });
+        return req;
+    }
     /**
      * 处理 WebSocket 升级请求；若有 getTarget 则按 Host/path 解析目标（与 HTTP 规则一致）
      */
@@ -247,53 +319,6 @@ export class HttpTunnelClient {
             this.wsClients.delete(message.requestId);
         }
     }
-    /**
-     * 发送 HTTP 请求到本地服务
-     */
-    sendHttpRequest(method, targetUrl, headers, body) {
-        return new Promise((resolve, reject) => {
-            const urlObj = new URL(targetUrl);
-            const isHttps = urlObj.protocol === 'https:';
-            const httpModule = isHttps ? https : http;
-            // 移除可能导致问题的头部；转发到本机时协议统一为实际连接协议（http/https），避免本机误用 https
-            const safeHeaders = { ...headers };
-            delete safeHeaders['host'];
-            delete safeHeaders['content-length'];
-            const forwardedProto = isHttps ? 'https' : 'http';
-            safeHeaders['x-forwarded-proto'] = forwardedProto;
-            safeHeaders['x-forwarded-scheme'] = forwardedProto;
-            const options = {
-                hostname: urlObj.hostname,
-                port: urlObj.port || (isHttps ? 443 : 80),
-                path: urlObj.pathname + urlObj.search,
-                method,
-                headers: safeHeaders,
-                agent: isHttps ? this.httpsAgent : this.httpAgent,
-                rejectUnauthorized: false,
-            };
-            const req = httpModule.request(options, (res) => {
-                const chunks = [];
-                res.on('data', (chunk) => {
-                    chunks.push(chunk);
-                });
-                res.on('end', () => {
-                    resolve({
-                        statusCode: res.statusCode || 200,
-                        statusMessage: res.statusMessage,
-                        headers: res.headers,
-                        body: chunks.length > 0 ? Buffer.concat(chunks) : undefined,
-                    });
-                });
-            });
-            req.on('error', (error) => {
-                reject(error);
-            });
-            if (body) {
-                req.write(body);
-            }
-            req.end();
-        });
-    }
     /**
      * 构建目标 URL
      */
@@ -356,10 +381,10 @@ export class HttpTunnelClient {
      * 关闭客户端
      */
     close() {
-        // 关闭所有 WebSocket 客户端
+        this.pendingStreamRequests.forEach((p) => p.req.destroy());
+        this.pendingStreamRequests.clear();
         this.wsClients.forEach((ws) => ws.close());
         this.wsClients.clear();
-        // 关闭代理
         this.httpAgent.destroy();
         this.httpsAgent.destroy();
     }