wapi-client 0.6.11 → 0.6.15

package/dist/lib/isomorphic/node/streams.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { DuplexOptions, PassThrough, Transform, TransformOptions, Writable, Readable, ReadableOptions } from 'stream';
 /**
  * @internal

package/dist/wapi-client.cjs.development.js

@@ -350,33 +350,30 @@ var require_buffer_util = __commonJS({
       }
       return buf;
     }
-    try {
-      const bufferUtil = require_bufferutil();
-      module2.exports = {
-        concat,
-        mask(source, mask, output, offset, length) {
+    module2.exports = {
+      concat,
+      mask: _mask,
+      toArrayBuffer,
+      toBuffer,
+      unmask: _unmask
+    };
+    if (!process.env.WS_NO_BUFFER_UTIL) {
+      try {
+        const bufferUtil = require_bufferutil();
+        module2.exports.mask = function(source, mask, output, offset, length) {
           if (length < 48)
             _mask(source, mask, output, offset, length);
           else
             bufferUtil.mask(source, mask, output, offset, length);
-        },
-        toArrayBuffer,
-        toBuffer,
-        unmask(buffer, mask) {
+        };
+        module2.exports.unmask = function(buffer, mask) {
           if (buffer.length < 32)
             _unmask(buffer, mask);
           else
             bufferUtil.unmask(buffer, mask);
-        }
-      };
-    } catch (e) {
-      module2.exports = {
-        concat,
-        mask: _mask,
-        toArrayBuffer,
-        toBuffer,
-        unmask: _unmask
-      };
+        };
+      } catch (e) {
+      }
     }
   }
 });
@@ -884,21 +881,19 @@ var require_validation = __commonJS({
       }
       return true;
     }
-    try {
-      const isValidUTF8 = require_utf_8_validate();
-      module2.exports = {
-        isValidStatusCode,
-        isValidUTF8(buf) {
+    module2.exports = {
+      isValidStatusCode,
+      isValidUTF8: _isValidUTF8,
+      tokenChars
+    };
+    if (!process.env.WS_NO_UTF_8_VALIDATE) {
+      try {
+        const isValidUTF8 = require_utf_8_validate();
+        module2.exports.isValidUTF8 = function(buf) {
           return buf.length < 150 ? _isValidUTF8(buf) : isValidUTF8(buf);
-        },
-        tokenChars
-      };
-    } catch (e) {
-      module2.exports = {
-        isValidStatusCode,
-        isValidUTF8: _isValidUTF8,
-        tokenChars
-      };
+        };
+      } catch (e) {
+      }
     }
   }
 });
@@ -2278,6 +2273,7 @@ var require_websocket = __commonJS({
       let req;
       if (opts.followRedirects) {
         if (websocket._redirects === 0) {
+          websocket._originalSecure = isSecure;
           websocket._originalHost = parsedUrl.host;
           const headers = options && options.headers;
           options = __spreadProps(__spreadValues({}, options), { headers: {} });
@@ -2286,11 +2282,15 @@ var require_websocket = __commonJS({
               options.headers[key2.toLowerCase()] = value;
             }
           }
-        } else if (websocket.listenerCount("redirect") === 0 && parsedUrl.host !== websocket._originalHost) {
-          delete opts.headers.authorization;
-          delete opts.headers.cookie;
-          delete opts.headers.host;
-          opts.auth = void 0;
+        } else if (websocket.listenerCount("redirect") === 0) {
+          const isSameHost = parsedUrl.host === websocket._originalHost;
+          if (!isSameHost || websocket._originalSecure && !isSecure) {
+            delete opts.headers.authorization;
+            delete opts.headers.cookie;
+            if (!isSameHost)
+              delete opts.headers.host;
+            opts.auth = void 0;
+          }
         }
         if (opts.auth && !options.headers.authorization) {
           options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
@@ -2340,6 +2340,10 @@ var require_websocket = __commonJS({
         if (websocket.readyState !== WebSocket2.CONNECTING)
           return;
         req = websocket._req = null;
+        if (res.headers.upgrade.toLowerCase() !== "websocket") {
+          abortHandshake(websocket, socket, "Invalid Upgrade header");
+          return;
+        }
         const digest = createHash("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
@@ -2815,10 +2819,31 @@ var require_websocket_server = __commonJS({
       }
       handleUpgrade(req, socket, head, cb) {
         socket.on("error", socketOnError);
-        const key = req.headers["sec-websocket-key"] !== void 0 ? req.headers["sec-websocket-key"] : false;
+        const key = req.headers["sec-websocket-key"];
         const version2 = +req.headers["sec-websocket-version"];
-        if (req.method !== "GET" || req.headers.upgrade.toLowerCase() !== "websocket" || !key || !keyRegex.test(key) || version2 !== 8 && version2 !== 13 || !this.shouldHandle(req)) {
-          return abortHandshake(socket, 400);
+        if (req.method !== "GET") {
+          const message = "Invalid HTTP method";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+          return;
+        }
+        if (req.headers.upgrade.toLowerCase() !== "websocket") {
+          const message = "Invalid Upgrade header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+          return;
+        }
+        if (!key || !keyRegex.test(key)) {
+          const message = "Missing or invalid Sec-WebSocket-Key header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+          return;
+        }
+        if (version2 !== 8 && version2 !== 13) {
+          const message = "Missing or invalid Sec-WebSocket-Version header";
+          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+          return;
+        }
+        if (!this.shouldHandle(req)) {
+          abortHandshake(socket, 400);
+          return;
         }
         const secWebSocketProtocol = req.headers["sec-websocket-protocol"];
         let protocols = /* @__PURE__ */ new Set();
@@ -2826,7 +2851,9 @@ var require_websocket_server = __commonJS({
           try {
             protocols = subprotocol.parse(secWebSocketProtocol);
           } catch (err) {
-            return abortHandshake(socket, 400);
+            const message = "Invalid Sec-WebSocket-Protocol header";
+            abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+            return;
           }
         }
         const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
@@ -2840,7 +2867,9 @@ var require_websocket_server = __commonJS({
               extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
             }
           } catch (err) {
-            return abortHandshake(socket, 400);
+            const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
+            abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+            return;
           }
         }
         if (this.options.verifyClient) {
@@ -2931,18 +2960,24 @@ var require_websocket_server = __commonJS({
       this.destroy();
     }
     function abortHandshake(socket, code, message, headers) {
-      if (socket.writable) {
-        message = message || http.STATUS_CODES[code];
-        headers = __spreadValues({
-          Connection: "close",
-          "Content-Type": "text/html",
-          "Content-Length": Buffer.byteLength(message)
-        }, headers);
-        socket.write(`HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
+      message = message || http.STATUS_CODES[code];
+      headers = __spreadValues({
+        Connection: "close",
+        "Content-Type": "text/html",
+        "Content-Length": Buffer.byteLength(message)
+      }, headers);
+      socket.once("finish", socket.destroy);
+      socket.end(`HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
 ` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message);
+    }
+    function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
+      if (server.listenerCount("wsClientError")) {
+        const err = new Error(message);
+        Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
+        server.emit("wsClientError", err, socket, req);
+      } else {
+        abortHandshake(socket, code, message);
       }
-      socket.removeListener("error", socketOnError);
-      socket.destroy();
     }
   }
 });
@@ -13645,10 +13680,7 @@ function toQueryString(obj) {
   return Object.keys(obj).filter((key) => obj[key] !== void 0).map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(obj[key])}`).join("&");
 }
 function getConnectionUrl(config) {
-  let url = config.host;
-  if (typeof window !== "undefined") {
-    url = config.host.replace(/^https:/, "wss:");
-  }
+  const url = config.host.replace(/^https:/, "wss:");
   return url + "?" + toQueryString({
     apikey: config.apikey,
     apisecret: config.apisecret,
@@ -29959,7 +29991,7 @@ var BaseClient = class {
 };
 
 // package.json
-var version = "0.6.11";
+var version = "0.6.15";
 
 // src/api/ws-client.ts
 function createClient(opts) {
@@ -30151,6 +30183,7 @@ function createClient2(opts) {
   return new HttpClient(initialConnection, opts);
 }
 function createConnection2(opts) {
+  const url = opts.host.replace(/^wss:/, "https:");
   function onmessage(body) {
     return __async(this, null, function* () {
       debugLog(`http_createConnection>message(body:${body})`);
@@ -30171,7 +30204,7 @@ function createConnection2(opts) {
       this.onmessage(__spreadProps(__spreadValues({}, responseBody), { id: jsonBody.id }));
     });
   }
-  const $connect = (0, import_node_ponyfill.default)(`${opts.host}/api`, {
+  const $connect = (0, import_node_ponyfill.default)(`${url}/api`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${opts.jwt}`