@wenbin_wb/dsh-bridge 1.0.5 → 1.0.7

package/README.md

@@ -2,132 +2,178 @@
 
 ![dsh-bridge banner](docs/banner.jpg)
 
+> Multi-channel remote access plugin for DeepSeek Harness  
 > DeepSeek Harness 多通道远程访问插件
 
+Seamlessly extend your local DeepSeek Harness to mobile phones, tablets, public networks, and even IM chat apps. Access your AI assistant anytime, anywhere via QR code scanning, web browsers, or future integrations with WeChat/QQ/Feishu.
+
 把你本地的 DeepSeek Harness 无缝延伸到手机、平板、公网、甚至 IM 聊天软件。无论你在哪，都能通过扫码、网页或未来的微信/QQ/飞书，随时调用你的 AI 助手。
 
-在 DSH 设置页新增「远程访问」面板，开箱即用地获得：
+---
+
+## Features / 功能特性
+
+### English
+
+- **LAN Access**: Scan QR code with your smartphone/tablet, direct access on the same Wi-Fi
+- **Cloudflare Tunnel**: One-click public internet exposure, connect from anywhere
+- **Custom Tunnel**: Connect to your own tunnel server with a fixed domain ([Setup Guide](docs/custom-tunnel.md))
+- **IM Integration (Planned)**: WeChat / QQ / Feishu / OpenClaw direct chat integration
+- **Security Alerts**: URLs and QR codes with access warnings to prevent accidental sharing
+- **Auto Version Check**: Automatic update detection when entering the panel
+
+### 中文
 
-- **局域网访问**：手机扫码，同一 Wi-Fi 直接访问
+- **局域网访问**：手机/平板扫码，同一 Wi-Fi 直接访问
 - **Cloudflare 隧道**：一键暴露公网地址，随时随地连接
-- **自建隧道**：连接自己的隧道服务器，获得固定域名
+- **自建隧道**：连接自己的隧道服务器，获得固定域名（[搭建教程](docs/custom-tunnel.md)）
 - **IM 集成（规划中）**：微信 / QQ / 飞书 / OpenClaw，直接在聊天软件里呼唤你的 Agent
+- **安全提示**：URL 和二维码带访问警告，防止误分享
+- **版本检查**：进入面板自动检测是否有新版本
 
 ![npm](https://img.shields.io/npm/v/@wenbin_wb/dsh-bridge?label=npm)
 ![npm downloads](https://img.shields.io/npm/dt/@wenbin_wb/dsh-bridge?label=downloads)
 ![npm license](https://img.shields.io/npm/l/@wenbin_wb/dsh-bridge?label=license)
 ![Node](https://img.shields.io/badge/node-%3E%3D22-brightgreen)
 
-## 功能
-
-- **局域网访问**：自动检测本机 IP，生成二维码，同一 Wi-Fi 下的设备直接扫码访问
-- **Cloudflare 隧道**：一键获取公网地址，自动下载 cloudflared（无需手动安装），重启后 URL 会变化
-- **自建隧道**：WebSocket 反向隧道，连接自己部署的隧道服务器，可获得固定域名
-- **安全提示**：URL 和二维码带访问警告，防止误分享
-- **版本检查**：进入面板自动检测是否有新版本
+---
 
 ## Roadmap
 
-除了现有的三种访问方式，正在规划：
+| Target / 目标 | Description / 说明 | Status / 状态 |
+|---------------|-------------------|--------------|
+| **WeChat / 微信** | Chat with your Agent directly in WeChat / 在微信里直接与你的 Agent 对话 | Planned / 规划中 |
+| **QQ Bot** | QQ bot integration for group/private chat / 接入 QQ 机器人，群聊/私聊唤起 Agent | Planned / 规划中 |
+| **Feishu / 飞书** | Feishu message/bot integration for workplace scenarios / 飞书消息/机器人集成，办公场景直接调用 | Planned / 规划中 |
+| **OpenClaw** | Integration with OpenClaw ecosystem / 与 OpenClaw 生态打通 | Planned / 规划中 |
+| **Telegram** | Self-hosted IM channel / 适合自托管的 IM 渠道 | Planned / 规划中 |
 
-| 目标 | 说明 | 状态 |
-|------|------|------|
-| **微信** | 在微信里直接与你的 Agent 对话 | 规划中 |
-| **QQ Bot** | 接入 QQ 机器人，群聊/私聊唤起 Agent | 规划中 |
-| **飞书** | 飞书消息/机器人集成，办公场景直接调用 | 规划中 |
-| **OpenClaw** | 与 OpenClaw 生态打通 | 规划中 |
-| **Telegram** | 适合自托管的 IM 渠道 | 规划中 |
+---
 
-## 环境要求
+## Requirements / 环境要求
 
+Before installing the plugin, ensure:  
 安装插件前，请先确保：
 
-1. **Node.js ≥ 22**（DSH 要求 `^22.19.0` 或 `≥ 24.0.0`）
-2. **dsh CLI 可用**——即能在终端直接运行 `dsh` 命令
+1. **Node.js ≥ 22** (DSH requires `^22.19.0` or `≥ 24.0.0` / DSH 要求)
+2. **dsh CLI available** — you can run `dsh` command in terminal / 能在终端直接运行 `dsh` 命令
 
 ```bash
-# 检查 Node 版本
-node -v   # 应显示 v22.19+ 或 v24+
+# Check Node version / 检查 Node 版本
+node -v   # Should show v22.19+ or v24+ / 应显示
 
-# 检查 dsh 是否可用
+# Check dsh availability / 检查 dsh 是否可用
 dsh --version
 ```
 
-如果 `dsh` 命令提示"无法识别/找不到"，说明它没有全局安装，先安装 DSH：
+If `dsh` command is not found, install DSH globally:  
+如果 `dsh` 命令提示"无法识别/找不到"，先安装 DSH：
 
 ```bash
 npm install -g @deepseek-ai/dsh
 ```
 
-> 若没有全局安装的权限，也可以用 `npx` 方式（无需全局安装）：
+> Alternative without global install (use `npx`):  
+> 若没有全局安装的权限，也可以用 `npx` 方式：
 > ```bash
 > npx --yes @deepseek-ai/dsh plugin --profile web add @wenbin_wb/dsh-bridge
 > ```
 
-## 安装
+---
 
-从 npm 安装：
+## Installation / 安装
+
+### From npm / 从 npm 安装
 
 ```bash
 dsh plugin --profile web add @wenbin_wb/dsh-bridge
 ```
 
-从源码安装：
+### From source / 从源码安装
 
 ```bash
 git clone https://github.com/wenbin-wb/dsh-bridge.git
 dsh plugin --profile web add ./dsh-bridge
 ```
 
+After installation, restart DSH and find "Remote Access" in settings.  
 安装完成后重启 DSH，在设置页找到「远程访问」即可使用。
 
-## 使用
+---
+
+## Usage / 使用
+
+### LAN Access / 局域网访问
+
+**English**: Automatically enabled after plugin starts, no configuration needed. Open Settings → "Remote Access", scan the QR code with your mobile device.
+
+**中文**：插件启动后自动开启，无需任何配置。打开设置页「远程访问」，用手机扫描二维码即可访问。
 
-### 局域网访问
+### Cloudflare Tunnel
 
-插件启动后自动开启，无需任何配置。打开设置页「远程访问」，用手机扫描二维码即可访问。
+**English**: 
+1. Click "Enable" in the Cloudflare Tunnel card
+2. First use will auto-download cloudflared (~30MB) from GitHub
+3. Public URL and QR code appear within seconds
+4. URL changes after each restart; click "Reset Link" to get a new one
 
-### Cloudflare 隧道
+**中文**：
+1. 点击「Cloudflare 隧道」卡片中的「开启」按钮
+2. 首次使用会自动从 GitHub 下载 cloudflared（约 30MB）
+3. 下载完成后自动启动，几秒内显示公网 URL 和二维码
+4. 每次重启后 URL 会变化；点「重置链接」可主动获取新 URL
 
-点击「Cloudflare 隧道」卡片中的「开启」按钮：
-1. 首次使用会自动从 GitHub 下载 cloudflared（约 30MB），需要能访问 GitHub
-2. 下载完成后自动启动，几秒内显示公网 URL 和二维码
-3. 每次重启后 URL 会变化；点「重置链接」可主动获取新 URL
+### Custom Tunnel / 自建隧道
 
-### 自建隧道
+**English**: Requires a server with public IP. See [Custom Tunnel Guide](docs/custom-tunnel.md) for detailed setup.
 
-需要一台有公网 IP 的服务器。详细搭建步骤见 [自建隧道教程](docs/custom-tunnel.md)。
+1. Deploy tunnel server following the guide
+2. Fill in WebSocket address (`wss://...`) and access token in the "Custom Tunnel" card
+3. Click "Save Config" then "Enable"
+
+Config is auto-persisted to `~/.dsh/dsh-bridge/config.json`, no need to re-enter after restart.
+
+**中文**：需要一台有公网 IP 的服务器。详细搭建步骤见 [自建隧道教程](docs/custom-tunnel.md)。
 
 1. 按教程在服务器上部署隧道服务端
 2. 在「自建隧道」卡片中填写 WebSocket 地址（`wss://...`）和访问令牌
 3. 点「保存配置」后点「开启」
 
-配置自动持久化到 `~/.dsh/dsh-bridge/config.json`，重启后无需重新填写。
+配置自动持久化，重启后无需重新填写。
+
+---
 
-## 可选配置
+## Optional Configuration / 可选配置
 
+Plugin works out-of-the-box, no configuration needed. To change proxy port, add to cordis.yml:  
 插件开箱即用，无需配置。如需修改代理端口，在 cordis.yml 中添加：
 
 ```yaml
 - name: dsh-bridge
   config:
-    port: 3082  # 默认 3082
+    port: 3082  # Default / 默认 3082
 ```
 
-## 开发
+---
+
+## Development / 开发
 
 ```bash
 git clone https://github.com/wenbin-wb/dsh-bridge.git
 cd dsh-bridge
 npm install
 
+# Rebuild after modifying client/index.js
 # 修改 client/index.js 后重新构建
 npm run build:client
 
+# Install to web profile and restart DSH
 # 安装到 web profile 并重启 DSH
 dsh plugin --profile web add .
 ```
 
+---
+
 ## License
 
 MIT © [wenbin-wb](https://github.com/wenbin-wb)

package/lib/tunnel-client.mjs

@@ -1,20 +1,12 @@
 // DSH Bridge - Custom Tunnel Client
-// WebSocket-based reverse tunnel with automatic reconnection and health monitoring
-
 import { WebSocket } from 'ws';
 import { request as httpRequest } from 'node:http';
+import { connect as netConnect } from 'node:net';
 
-const HEARTBEAT_INTERVAL = 30000; // 30 seconds
-const RECONNECT_DELAY = 5000; // 5 seconds
+const HEARTBEAT_INTERVAL = 30000;
+const RECONNECT_DELAY = 5000;
 const MAX_RECONNECT_ATTEMPTS = 5;
 
-/**
- * Custom tunnel client with production-grade features:
- * - Automatic reconnection with exponential backoff
- * - Heartbeat monitoring
- * - Request multiplexing
- * - Graceful shutdown
- */
 export class CustomTunnelClient {
   constructor({ serverUrl, accessToken, localPort, signal, onStateChange, logger }) {
     this.serverUrl = serverUrl;
@@ -23,7 +15,6 @@ export class CustomTunnelClient {
     this.signal = signal;
     this.onStateChange = onStateChange;
     this.logger = logger;
-    
     this.ws = null;
     this.publicUrl = null;
     this.connected = false;
@@ -32,14 +23,12 @@ export class CustomTunnelClient {
     this.reconnectTimer = null;
     this.heartbeatTimer = null;
     this.pendingRequests = new Map();
-    this.requestIdCounter = 0;
+    this.localWsSockets = new Map(); // wsId -> net.Socket
   }
-  
+
   async connect() {
     if (this.connected) return;
-    
     this._setState('connecting', 'Connecting to tunnel server...');
-    
     try {
       await this._connectWebSocket();
       this._startHeartbeat();
@@ -50,57 +39,47 @@ export class CustomTunnelClient {
       throw err;
     }
   }
-  
+
   _connectWebSocket() {
     return new Promise((resolve, reject) => {
-      if (this.signal?.aborted) {
-        return reject(new Error('Aborted'));
-      }
-      
+      if (this.signal?.aborted) return reject(new Error('Aborted'));
+
       const url = new URL(this.serverUrl);
       url.searchParams.set('token', this.accessToken);
-      
+
       this.ws = new WebSocket(url.toString(), {
         handshakeTimeout: 10000,
         perMessageDeflate: false,
       });
-      
-      const onAbort = () => {
-        this.ws?.terminate();
-        reject(new Error('Aborted'));
-      };
-      
+
+      const onAbort = () => { this.ws?.terminate(); reject(new Error('Aborted')); };
       this.signal?.addEventListener('abort', onAbort);
-      
+
       this.ws.on('open', () => {
         this.signal?.removeEventListener('abort', onAbort);
         this.logger?.info('Tunnel WebSocket connected');
       });
-      
-      this.ws.on('message', (data) => {
-        this._handleMessage(data);
-      });
-      
+
+      this.ws.on('message', (data) => this._handleMessage(data));
+
       this.ws.on('close', (code, reason) => {
         this.connected = false;
         this._stopHeartbeat();
-        
+        this._cleanupLocalWs();
         if (!this.signal?.aborted) {
           this.logger?.warn('Tunnel disconnected: code=%d, reason=%s', code, reason.toString());
           this._scheduleReconnect();
         }
       });
-      
+
       this.ws.on('error', (err) => {
         this.logger?.error('Tunnel WebSocket error: %s', err.message);
-        
         if (!this.connected) {
           this.signal?.removeEventListener('abort', onAbort);
           reject(err);
         }
       });
-      
-      // Listen for 'ready' message from server
+
       const readyHandler = (data) => {
         try {
           const msg = JSON.parse(data.toString());
@@ -114,10 +93,8 @@ export class CustomTunnelClient {
           }
         } catch {}
       };
-      
       this.ws.on('message', readyHandler);
-      
-      // Timeout
+
       setTimeout(() => {
         if (!this.connected) {
           this.signal?.removeEventListener('abort', onAbort);
@@ -127,126 +104,150 @@ export class CustomTunnelClient {
       }, 15000);
     });
   }
-  
+
   _handleMessage(data) {
     try {
       const msg = JSON.parse(data.toString());
-      
-      // HTTP request from server
-      if (msg.type === 'request') {
-        this._handleHttpRequest(msg);
-      }
-      // Response for our request
-      else if (msg.type === 'response') {
-        this._handleHttpResponse(msg);
-      }
-      // Heartbeat pong
-      else if (msg.type === 'pong') {
-        // Server is alive
-      }
+      if      (msg.type === 'request')  this._handleHttpRequest(msg);
+      else if (msg.type === 'ws-open')  this._handleWsOpen(msg);
+      else if (msg.type === 'ws-frame') this._handleWsFrame(msg);
+      else if (msg.type === 'ws-close') this._handleWsClose(msg);
+      // pong: ignore
     } catch (err) {
       this.logger?.error('Failed to parse tunnel message: %s', err.message);
     }
   }
-  
+
+  // ── HTTP 请求代理 ─────────────────────────────────────────────────────────
   _handleHttpRequest(msg) {
     const { requestId, method, path, headers } = msg;
-
-    // 过滤掉会干扰本地 HTTP 的 hop-by-hop 头
-    const SKIP_HEADERS = new Set([
-      'transfer-encoding', 'connection', 'keep-alive',
-      'proxy-authenticate', 'proxy-authorization',
-      'te', 'trailer', 'upgrade',
-    ]);
+    const SKIP = new Set(['transfer-encoding','connection','keep-alive',
+      'proxy-authenticate','proxy-authorization','te','trailer','upgrade']);
     const safeHeaders = Object.fromEntries(
-      Object.entries(headers ?? {}).filter(([k]) => !SKIP_HEADERS.has(k.toLowerCase()))
+      Object.entries(headers ?? {}).filter(([k]) => !SKIP.has(k.toLowerCase()))
     );
 
     const req = httpRequest({
-      host: '127.0.0.1',
-      port: this.localPort,
-      method,
-      path: path || '/',
-      headers: {
-        ...safeHeaders,
-        host: `127.0.0.1:${this.localPort}`,
-      },
+      host: '127.0.0.1', port: this.localPort,
+      method, path: path || '/',
+      headers: { ...safeHeaders, host: `127.0.0.1:${this.localPort}` },
     }, (res) => {
       const chunks = [];
-      res.on('data', (chunk) => { chunks.push(chunk); });
-      res.on('error', (err) => {
-        this.logger?.error('Response read error: %s', err.message);
-        this._sendMessage({
-          type: 'response', requestId,
-          statusCode: 502,
+      res.on('data', c => chunks.push(c));
+      res.on('error', () => {
+        this._sendMessage({ type: 'response', requestId, statusCode: 502,
           headers: { 'content-type': 'text/plain' },
-          body: Buffer.from('Response Error').toString('base64'),
-        });
+          body: Buffer.from('Response Error').toString('base64') });
       });
       res.on('end', () => {
-        // 过滤响应头里的 hop-by-hop，防止外层 HTTP 解析出错
         const respHeaders = Object.fromEntries(
-          Object.entries(res.headers).filter(([k]) => !SKIP_HEADERS.has(k.toLowerCase()))
+          Object.entries(res.headers).filter(([k]) => !SKIP.has(k.toLowerCase()))
         );
-        this._sendMessage({
-          type: 'response',
-          requestId,
-          statusCode: res.statusCode,
-          headers: respHeaders,
-          body: Buffer.concat(chunks).toString('base64'),
-        });
+        this._sendMessage({ type: 'response', requestId,
+          statusCode: res.statusCode, headers: respHeaders,
+          body: Buffer.concat(chunks).toString('base64') });
       });
     });
-
-    req.on('error', (err) => {
-      this.logger?.error('Local request failed: %s', err.message);
-      this._sendMessage({
-        type: 'response', requestId,
-        statusCode: 502,
+    req.on('error', err => {
+      this._sendMessage({ type: 'response', requestId, statusCode: 502,
         headers: { 'content-type': 'text/plain' },
-        body: Buffer.from(`Bad Gateway: ${err.message}`).toString('base64'),
-      });
+        body: Buffer.from(`Bad Gateway: ${err.message}`).toString('base64') });
     });
-
-    if (msg.body) {
-      req.write(Buffer.from(msg.body, 'base64'));
-    }
+    if (msg.body) req.write(Buffer.from(msg.body, 'base64'));
     req.end();
   }
-  
-  _handleHttpResponse(msg) {
-    const { requestId, statusCode, headers, body } = msg;
-    const pending = this.pendingRequests.get(requestId);
-    
-    if (pending) {
-      pending.resolve({ statusCode, headers, body });
-      this.pendingRequests.delete(requestId);
-    }
+
+  // ── WebSocket 升级代理 ────────────────────────────────────────────────────
+  // 服务端通知有浏览器要建 WebSocket，用裸 TCP 连本地 DSH 完成握手再转发帧
+  _handleWsOpen(msg) {
+    const { wsId, path, headers } = msg;
+
+    const sock = netConnect({ host: '127.0.0.1', port: this.localPort });
+    this.localWsSockets.set(wsId, sock);
+
+    // 构造 HTTP Upgrade 请求
+    const reqHeaders = { ...headers, host: `127.0.0.1:${this.localPort}` };
+    delete reqHeaders['proxy-connection'];
+    delete reqHeaders['proxy-authorization'];
+
+    const lines = [`GET ${path || '/'} HTTP/1.1`];
+    for (const [k, v] of Object.entries(reqHeaders)) lines.push(`${k}: ${v}`);
+    lines.push('', '');
+    sock.write(lines.join('\r\n'));
+
+    let headerBuf = '';
+    let upgraded = false;
+
+    sock.on('data', (chunk) => {
+      if (upgraded) {
+        this._sendMessage({ type: 'ws-frame', wsId, data: chunk.toString('base64') });
+        return;
+      }
+      headerBuf += chunk.toString('binary');
+      const sep = headerBuf.indexOf('\r\n\r\n');
+      if (sep === -1) return;
+
+      upgraded = true;
+      const replyHeaders = {};
+      const headerLines = headerBuf.slice(0, sep).split('\r\n');
+      for (let i = 1; i < headerLines.length; i++) {
+        const ci = headerLines[i].indexOf(':');
+        if (ci > 0) {
+          replyHeaders[headerLines[i].slice(0, ci).trim().toLowerCase()] =
+            headerLines[i].slice(ci + 1).trim();
+        }
+      }
+      this._sendMessage({ type: 'ws-accept', wsId, replyHeaders });
+
+      // 握手后紧跟的帧数据
+      const rest = headerBuf.slice(sep + 4);
+      if (rest.length > 0) {
+        this._sendMessage({ type: 'ws-frame', wsId, data: Buffer.from(rest, 'binary').toString('base64') });
+      }
+    });
+
+    sock.on('close', () => {
+      this._sendMessage({ type: 'ws-close', wsId });
+      this.localWsSockets.delete(wsId);
+    });
+    sock.on('error', (err) => {
+      this.logger?.error('Local WS socket error wsId=%s: %s', wsId, err.message);
+      this._sendMessage({ type: 'ws-close', wsId });
+      this.localWsSockets.delete(wsId);
+    });
+  }
+
+  _handleWsFrame(msg) {
+    const sock = this.localWsSockets.get(msg.wsId);
+    if (sock && !sock.destroyed) sock.write(Buffer.from(msg.data, 'base64'));
+  }
+
+  _handleWsClose(msg) {
+    const sock = this.localWsSockets.get(msg.wsId);
+    if (sock) { sock.destroy(); this.localWsSockets.delete(msg.wsId); }
+  }
+
+  _cleanupLocalWs() {
+    for (const [, sock] of this.localWsSockets) sock.destroy();
+    this.localWsSockets.clear();
   }
-  
+
+  // ── 工具方法 ──────────────────────────────────────────────────────────────
   _sendMessage(msg) {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(msg));
-    }
+    if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify(msg));
   }
-  
+
   _startHeartbeat() {
     this._stopHeartbeat();
-    
     this.heartbeatTimer = setInterval(() => {
-      if (this.connected) {
-        this._sendMessage({ type: 'ping' });
-      }
+      if (this.connected) this._sendMessage({ type: 'ping' });
     }, HEARTBEAT_INTERVAL);
   }
-  
+
   _stopHeartbeat() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
+    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
   }
-  
+
   _scheduleReconnect() {
     if (this.signal?.aborted || this.disconnecting) return;
     if (this.reconnectTimer) return;
@@ -254,50 +255,29 @@ export class CustomTunnelClient {
       this._setState('error', `Failed to reconnect after ${MAX_RECONNECT_ATTEMPTS} attempts`);
       return;
     }
-    
     this.reconnectAttempts++;
     const delay = RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts - 1);
-    
     this._setState('reconnecting', `Reconnecting in ${Math.round(delay / 1000)}s (attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
-    
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
-      this.connect().catch(() => {
-        // Will schedule another reconnect
-      });
+      this.connect().catch(() => {});
     }, delay);
   }
-  
+
   _setState(phase, detail) {
-    if (this.onStateChange) {
-      this.onStateChange({ phase, detail });
-    }
+    if (this.onStateChange) this.onStateChange({ phase, detail });
   }
-  
+
   disconnect() {
-    // Mark as disconnected (don't modify external signal)
     this.disconnecting = true;
     this._stopHeartbeat();
-    
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-    
+    this._cleanupLocalWs();
+    if (this.reconnectTimer) { clearTimeout(this.reconnectTimer); this.reconnectTimer = null; }
+    if (this.ws) { this.ws.close(); this.ws = null; }
     this.connected = false;
     this.publicUrl = null;
-    
-    // Reject all pending requests
-    for (const [id, pending] of this.pendingRequests) {
-      pending.reject(new Error('Disconnected'));
-      this.pendingRequests.delete(id);
-    }
-    
+    for (const [, p] of this.pendingRequests) p.reject(new Error('Disconnected'));
+    this.pendingRequests.clear();
     this.logger?.info('Tunnel disconnected');
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenbin_wb/dsh-bridge",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "DSH 多渠道接入桥：局域网二维码、自建隧道、机器人集成",
   "type": "module",
   "main": "lib/index.js",
@@ -40,9 +40,19 @@
     "dsh",
     "dsh-plugin",
     "remote",
+    "remote-access",
     "tunnel",
-    "qr",
-    "bot"
+    "cloudflare",
+    "mobile",
+    "smartphone",
+    "tablet",
+    "qr-code",
+    "qrcode",
+    "websocket",
+    "bot",
+    "wechat",
+    "qq",
+    "feishu"
   ],
   "dsh": {
     "bundle": {