connectbase-client 3.7.0 → 3.7.2

package/dist/cli.js

@@ -1456,6 +1456,129 @@ function createWsBinaryFrame(payload) {
   }
   return Buffer.concat([header, maskKey, masked]);
 }
+var UpstreamWsFrameParser = class {
+  constructor(handlers) {
+    this.buffer = Buffer.alloc(0);
+    this.fragmentBuffer = null;
+    this.h = handlers;
+  }
+  feed(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    try {
+      this.parse();
+    } catch (e) {
+      this.h.onError(e instanceof Error ? e : new Error(String(e)));
+    }
+  }
+  parse() {
+    while (this.buffer.length >= 2) {
+      const firstByte = this.buffer[0];
+      const secondByte = this.buffer[1];
+      const fin = (firstByte & 128) !== 0;
+      const rsv1 = (firstByte & 64) !== 0;
+      const opcode = firstByte & 15;
+      const isMasked = (secondByte & 128) !== 0;
+      let payloadLen = secondByte & 127;
+      let offset = 2;
+      if (payloadLen === 126) {
+        if (this.buffer.length < 4) return;
+        payloadLen = this.buffer.readUInt16BE(2);
+        offset = 4;
+      } else if (payloadLen === 127) {
+        if (this.buffer.length < 10) return;
+        const big = this.buffer.readBigUInt64BE(2);
+        if (big > BigInt(Number.MAX_SAFE_INTEGER)) {
+          throw new Error(`payload too large: ${big}`);
+        }
+        payloadLen = Number(big);
+        offset = 10;
+      }
+      let maskKey = null;
+      if (isMasked) {
+        if (this.buffer.length < offset + 4) return;
+        maskKey = this.buffer.subarray(offset, offset + 4);
+        offset += 4;
+      }
+      if (this.buffer.length < offset + payloadLen) return;
+      if (rsv1 && (opcode === 1 || opcode === 2 || opcode === 0)) {
+        throw new Error("upstream sent compressed (RSV1) frame without negotiation");
+      }
+      let payload = this.buffer.subarray(offset, offset + payloadLen);
+      if (maskKey) {
+        const unmasked = Buffer.alloc(payloadLen);
+        for (let i = 0; i < payloadLen; i++) {
+          unmasked[i] = payload[i] ^ maskKey[i % 4];
+        }
+        payload = unmasked;
+      }
+      this.buffer = this.buffer.subarray(offset + payloadLen);
+      const payloadCopy = Buffer.from(payload);
+      switch (opcode) {
+        case 0:
+          if (this.fragmentBuffer == null) {
+            throw new Error("continuation frame without preceding non-final data frame");
+          }
+          this.fragmentBuffer = Buffer.concat([this.fragmentBuffer, payloadCopy]);
+          if (fin) {
+            const out = this.fragmentBuffer;
+            this.fragmentBuffer = null;
+            this.h.onPayload(out);
+          }
+          break;
+        case 1:
+        // TEXT
+        case 2:
+          if (fin) {
+            this.h.onPayload(payloadCopy);
+          } else {
+            this.fragmentBuffer = payloadCopy;
+          }
+          break;
+        case 8:
+          this.h.onClose();
+          break;
+        case 9:
+          this.h.onPing(payloadCopy);
+          break;
+        case 10:
+          break;
+        default:
+          throw new Error(`unknown WS opcode 0x${opcode.toString(16)}`);
+      }
+    }
+  }
+};
+function createUpstreamTextFrame(payload) {
+  return buildClientFrame(129, payload);
+}
+function createUpstreamPongFrame(payload) {
+  return buildClientFrame(138, payload);
+}
+function buildClientFrame(firstByte, payload) {
+  const len = payload.length;
+  const maskKey = crypto.randomBytes(4);
+  let header;
+  if (len < 126) {
+    header = Buffer.alloc(2);
+    header[0] = firstByte;
+    header[1] = 128 | len;
+  } else if (len < 65536) {
+    header = Buffer.alloc(4);
+    header[0] = firstByte;
+    header[1] = 128 | 126;
+    header.writeUInt16BE(len, 2);
+  } else {
+    header = Buffer.alloc(10);
+    header[0] = firstByte;
+    header[1] = 128 | 127;
+    header.writeBigUInt64BE(BigInt(len), 2);
+  }
+  const masked = Buffer.alloc(len);
+  for (let i = 0; i < len; i++) {
+    masked[i] = payload[i] ^ maskKey[i % 4];
+  }
+  return Buffer.concat([header, maskKey, masked]);
+}
 var WsFrameParser = class {
   constructor(handlers) {
     this.buffer = Buffer.alloc(0);
@@ -1951,9 +2074,14 @@ ${colors.cyan}ConnectBase Tunnel${colors.reset}`);
     const fullPath = query ? `${reqPath}?${query}` : reqPath;
     const localHeaders = {};
     for (const [k, v] of Object.entries(headers)) {
-      if (k.toLowerCase() !== "host") localHeaders[k] = v;
+      const lk = k.toLowerCase();
+      if (lk === "host") continue;
+      if (lk === "sec-websocket-extensions") continue;
+      localHeaders[k] = v;
     }
     localHeaders["host"] = `localhost:${localPort}`;
+    localHeaders["connection"] = "Upgrade";
+    localHeaders["upgrade"] = "websocket";
     let cancelled = false;
     let upstream = null;
     const req = http.request({
@@ -1978,9 +2106,28 @@ ${colors.cyan}ConnectBase Tunnel${colors.reset}`);
         websocket: true
       });
       log(`${colors.dim}${(/* @__PURE__ */ new Date()).toLocaleTimeString()}${colors.reset} ${colors.cyan}WS${colors.reset} ${reqPath} \u2192 101`);
+      const upstreamParser = new UpstreamWsFrameParser({
+        onPayload: (payload) => {
+          if (cancelled) return;
+          sendBinary(sock, streamId, payload);
+        },
+        onPing: (payload) => {
+          if (cancelled || !upstream) return;
+          upstream.write(createUpstreamPongFrame(payload));
+        },
+        onClose: () => {
+          if (cancelled) return;
+          sendControl(sock, { type: "stream_close", stream_id: streamId });
+          streams.delete(streamId);
+        },
+        onError: (err) => {
+          sendControl(sock, { type: "stream_close", stream_id: streamId, error: `upstream_frame_error: ${err.message}` });
+          streams.delete(streamId);
+        }
+      });
       sk.on("data", (chunk) => {
         if (cancelled) return;
-        sendBinary(sock, streamId, chunk);
+        upstreamParser.feed(chunk);
       });
       sk.on("close", () => {
         if (cancelled) return;
@@ -2015,8 +2162,16 @@ ${colors.cyan}ConnectBase Tunnel${colors.reset}`);
     req.end();
     const forwarder = {
       kind: "ws",
+      // Encode the v2 payload as an upstream WS frame BEFORE writing to
+      // the socket. The prior implementation wrote raw payload to the
+      // socket which is not a valid WS frame; upstream WS servers (e.g.
+      // ComfyUI) would error out. Default to TEXT opcode — the v2
+      // protocol does not propagate the original opcode from the client,
+      // and most WS APIs (JSON-based) use text. Binary client→upstream
+      // is a known limitation pending opcode propagation in v2.
       feedBody: (chunk) => {
-        if (!cancelled && upstream) upstream.write(chunk);
+        if (cancelled || !upstream) return;
+        upstream.write(createUpstreamTextFrame(chunk));
       },
       endBody: () => {
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "connectbase-client",
-  "version": "3.7.0",
+  "version": "3.7.2",
   "description": "Connect Base JavaScript/TypeScript SDK for browser and Node.js",
   "repository": {
     "type": "git",