@wenbin_wb/dsh-bridge 1.0.5 → 1.0.6

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.6",
   "description": "DSH 多渠道接入桥：局域网二维码、自建隧道、机器人集成",
   "type": "module",
   "main": "lib/index.js",