@tiktool/live 1.6.6 → 2.1.0

package/dist/index.mjs

@@ -1,11 +1,32 @@
-// src/client.ts
-import { EventEmitter } from "events";
-import * as http from "http";
-import * as https from "https";
-import * as zlib from "zlib";
-import WebSocket from "ws";
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/proto.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function concatBytes(...arrays) {
+  let totalLength = 0;
+  for (const arr of arrays) totalLength += arr.length;
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function readInt32LE(buf, offset) {
+  return buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16 | buf[offset + 3] << 24;
+}
+function readBigInt64LE(buf, offset) {
+  const lo = BigInt(buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16 | buf[offset + 3] << 24 >>> 0);
+  const hi = BigInt(buf[offset + 4] | buf[offset + 5] << 8 | buf[offset + 6] << 16 | buf[offset + 7] << 24 >>> 0);
+  return hi << 32n | lo & 0xFFFFFFFFn;
+}
 function decodeVarint(buf, offset) {
   let result = 0, shift = 0;
   while (offset < buf.length) {
@@ -35,15 +56,15 @@ function encodeVarint(v) {
     if (n > 0n) b |= 128;
     bytes.push(b);
   } while (n > 0n);
-  return Buffer.from(bytes);
+  return new Uint8Array(bytes);
 }
 function encodeField(fn, wt, value) {
   const tag = encodeVarint(fn << 3 | wt);
   if (wt === 0) {
-    return Buffer.concat([tag, encodeVarint(typeof value === "number" ? BigInt(value) : value)]);
+    return concatBytes(tag, encodeVarint(typeof value === "number" ? BigInt(value) : value));
   }
-  const data = typeof value === "string" ? Buffer.from(value) : value;
-  return Buffer.concat([tag, encodeVarint(data.length), data]);
+  const data = typeof value === "string" ? encoder.encode(value) : value;
+  return concatBytes(tag, encodeVarint(data.length), data);
 }
 function decodeProto(buf) {
   const fields = [];
@@ -64,10 +85,10 @@ function decodeProto(buf) {
       offset += lenR.value;
       fields.push({ fn, wt, value: data });
     } else if (wt === 1) {
-      fields.push({ fn, wt, value: buf.readBigInt64LE(offset) });
+      fields.push({ fn, wt, value: readBigInt64LE(buf, offset) });
       offset += 8;
     } else if (wt === 5) {
-      fields.push({ fn, wt, value: BigInt(buf.readInt32LE(offset)) });
+      fields.push({ fn, wt, value: BigInt(readInt32LE(buf, offset)) });
       offset += 4;
     } else {
       break;
@@ -77,7 +98,7 @@ function decodeProto(buf) {
 }
 function getStr(fields, fn) {
   const f = fields.find((x) => x.fn === fn && x.wt === 2);
-  return f ? f.value.toString("utf-8") : "";
+  return f ? decoder.decode(f.value) : "";
 }
 function getBytes(fields, fn) {
   const f = fields.find((x) => x.fn === fn && x.wt === 2);
@@ -92,33 +113,33 @@ function getAllBytes(fields, fn) {
 }
 function buildHeartbeat(roomId) {
   const payload = encodeField(1, 0, BigInt(roomId));
-  return Buffer.concat([
+  return concatBytes(
     encodeField(6, 2, "pb"),
     encodeField(7, 2, "hb"),
     encodeField(8, 2, payload)
-  ]);
+  );
 }
 function buildImEnterRoom(roomId) {
-  const inner = Buffer.concat([
+  const inner = concatBytes(
     encodeField(1, 0, BigInt(roomId)),
     encodeField(4, 0, 12n),
     encodeField(5, 2, "audience"),
     encodeField(6, 2, ""),
     encodeField(9, 2, ""),
     encodeField(10, 2, "")
-  ]);
-  return Buffer.concat([
+  );
+  return concatBytes(
     encodeField(6, 2, "pb"),
     encodeField(7, 2, "im_enter_room"),
     encodeField(8, 2, inner)
-  ]);
+  );
 }
 function buildAck(id) {
-  return Buffer.concat([
+  return concatBytes(
     encodeField(2, 0, id),
     encodeField(6, 2, "pb"),
     encodeField(7, 2, "ack")
-  ]);
+  );
 }
 function parseUser(data) {
   const f = decodeProto(data);
@@ -131,7 +152,7 @@ function parseUser(data) {
     try {
       const avatarFields = decodeProto(avatarBuf);
       const urlBufs = getAllBytes(avatarFields, 1);
-      if (urlBufs.length > 0) profilePicture = urlBufs[0].toString("utf-8");
+      if (urlBufs.length > 0) profilePicture = decoder.decode(urlBufs[0]);
     } catch {
     }
   }
@@ -448,27 +469,47 @@ function parseWebcastResponse(payload) {
 // src/client.ts
 var DEFAULT_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
 var DEFAULT_SIGN_SERVER = "https://api.tik.tools";
-function httpGet(url, headers) {
-  return new Promise((resolve, reject) => {
-    const mod = url.startsWith("https") ? https : http;
-    const req = mod.get(url, { headers }, (res) => {
-      const chunks = [];
-      const enc = res.headers["content-encoding"];
-      const stream = enc === "gzip" || enc === "br" ? res.pipe(enc === "br" ? zlib.createBrotliDecompress() : zlib.createGunzip()) : res;
-      stream.on("data", (c) => chunks.push(c));
-      stream.on("end", () => resolve({
-        status: res.statusCode || 0,
-        headers: res.headers,
-        body: Buffer.concat(chunks)
-      }));
-      stream.on("error", reject);
-    });
-    req.on("error", reject);
-    req.setTimeout(15e3, () => {
-      req.destroy();
-      reject(new Error("Request timeout"));
-    });
-  });
+var TypedEmitter = class {
+  _listeners = /* @__PURE__ */ new Map();
+  on(event, fn) {
+    const arr = this._listeners.get(event) || [];
+    arr.push(fn);
+    this._listeners.set(event, arr);
+    return this;
+  }
+  once(event, fn) {
+    const wrapper = (...args) => {
+      this.off(event, wrapper);
+      fn(...args);
+    };
+    return this.on(event, wrapper);
+  }
+  off(event, fn) {
+    const arr = this._listeners.get(event);
+    if (arr) {
+      this._listeners.set(event, arr.filter((l) => l !== fn));
+    }
+    return this;
+  }
+  emit(event, ...args) {
+    const arr = this._listeners.get(event);
+    if (!arr || arr.length === 0) return false;
+    for (const fn of [...arr]) fn(...args);
+    return true;
+  }
+  removeAllListeners(event) {
+    if (event) this._listeners.delete(event);
+    else this._listeners.clear();
+    return this;
+  }
+};
+function gunzipSync(data) {
+  try {
+    const zlib = __require("zlib");
+    return new Uint8Array(zlib.gunzipSync(data));
+  } catch {
+    return data;
+  }
 }
 function getWsHost(clusterRegion) {
   if (!clusterRegion) return "webcast-ws.tiktok.com";
@@ -477,7 +518,21 @@ function getWsHost(clusterRegion) {
   if (r.startsWith("us") || r.includes("us")) return "webcast-ws.us.tiktok.com";
   return "webcast-ws.tiktok.com";
 }
-var TikTokLive = class extends EventEmitter {
+async function resolveWebSocket(userImpl) {
+  if (userImpl) return userImpl;
+  if (typeof globalThis.WebSocket !== "undefined") {
+    return globalThis.WebSocket;
+  }
+  try {
+    const ws = await import("ws");
+    return ws.default || ws;
+  } catch {
+    throw new Error(
+      'No WebSocket implementation found. Either use Node.js 22+ (native WebSocket), Cloudflare Workers, or install the "ws" package: npm i ws'
+    );
+  }
+}
+var TikTokLive = class extends TypedEmitter {
   ws = null;
   heartbeatTimer = null;
   reconnectAttempts = 0;
@@ -485,7 +540,6 @@ var TikTokLive = class extends EventEmitter {
   _connected = false;
   _eventCount = 0;
   _roomId = "";
-  // Cache host identities from battle events for enriching battleArmies
   _battleHosts = /* @__PURE__ */ new Map();
   uniqueId;
   signServerUrl;
@@ -494,6 +548,8 @@ var TikTokLive = class extends EventEmitter {
   maxReconnectAttempts;
   heartbeatInterval;
   debug;
+  webSocketImpl;
+  WS;
   constructor(options) {
     super();
     this.uniqueId = options.uniqueId.replace(/^@/, "");
@@ -504,24 +560,40 @@ var TikTokLive = class extends EventEmitter {
     this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
     this.heartbeatInterval = options.heartbeatInterval ?? 1e4;
     this.debug = options.debug ?? false;
+    this.webSocketImpl = options.webSocketImpl;
   }
   async connect() {
     this.intentionalClose = false;
-    const resp = await httpGet(`https://www.tiktok.com/@${this.uniqueId}/live`, {
-      "User-Agent": DEFAULT_UA,
-      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-      "Accept-Encoding": "gzip, deflate, br",
-      "Accept-Language": "en-US,en;q=0.9"
+    if (!this.WS) {
+      this.WS = await resolveWebSocket(this.webSocketImpl);
+    }
+    const resp = await fetch(`https://www.tiktok.com/@${this.uniqueId}/live`, {
+      headers: {
+        "User-Agent": DEFAULT_UA,
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.9"
+      },
+      redirect: "follow"
     });
     let ttwid = "";
-    for (const sc of [resp.headers["set-cookie"] || []].flat()) {
-      if (typeof sc === "string" && sc.startsWith("ttwid=")) {
-        ttwid = sc.split(";")[0].split("=").slice(1).join("=");
+    const setCookies = resp.headers.get("set-cookie") || "";
+    for (const part of setCookies.split(",")) {
+      const trimmed = part.trim();
+      if (trimmed.startsWith("ttwid=")) {
+        ttwid = trimmed.split(";")[0].split("=").slice(1).join("=");
         break;
       }
     }
+    if (!ttwid && typeof resp.headers.getSetCookie === "function") {
+      for (const sc of resp.headers.getSetCookie()) {
+        if (typeof sc === "string" && sc.startsWith("ttwid=")) {
+          ttwid = sc.split(";")[0].split("=").slice(1).join("=");
+          break;
+        }
+      }
+    }
     if (!ttwid) throw new Error("Failed to obtain session cookie");
-    const html = resp.body.toString();
+    const html = await resp.text();
     let roomId = "";
     const sigiMatch = html.match(/id="SIGI_STATE"[^>]*>([^<]+)/);
     if (sigiMatch) {
@@ -549,7 +621,7 @@ var TikTokLive = class extends EventEmitter {
       browser_name: "Mozilla",
       browser_version: DEFAULT_UA.split("Mozilla/")[1] || "5.0",
       browser_online: "true",
-      tz_name: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      tz_name: "Etc/UTC",
       app_name: "tiktok_web",
       sup_ws_ds_opt: "1",
       update_version_code: "2.0.0",
@@ -590,18 +662,27 @@ var TikTokLive = class extends EventEmitter {
       wsUrl = rawWsUrl.replace(/^https:\/\//, "wss://");
     }
     return new Promise((resolve, reject) => {
-      this.ws = new WebSocket(wsUrl, {
-        headers: {
-          "User-Agent": DEFAULT_UA,
-          "Cookie": `ttwid=${ttwid}`,
-          "Origin": "https://www.tiktok.com"
-        }
-      });
-      this.ws.on("open", () => {
+      const connUrl = wsUrl + (wsUrl.includes("?") ? "&" : "?") + `ttwid=${ttwid}`;
+      try {
+        this.ws = new this.WS(connUrl, {
+          headers: {
+            "User-Agent": DEFAULT_UA,
+            "Cookie": `ttwid=${ttwid}`,
+            "Origin": "https://www.tiktok.com"
+          }
+        });
+      } catch {
+        this.ws = new this.WS(connUrl);
+      }
+      const ws = this.ws;
+      let settled = false;
+      ws.onopen = () => {
         this._connected = true;
         this.reconnectAttempts = 0;
-        this.ws.send(buildHeartbeat(roomId));
-        this.ws.send(buildImEnterRoom(roomId));
+        const hb = buildHeartbeat(roomId);
+        const enter = buildImEnterRoom(roomId);
+        ws.send(hb.buffer.byteLength === hb.length ? hb.buffer : hb.buffer.slice(hb.byteOffset, hb.byteOffset + hb.byteLength));
+        ws.send(enter.buffer.byteLength === enter.length ? enter.buffer : enter.buffer.slice(enter.byteOffset, enter.byteOffset + enter.byteLength));
         this.startHeartbeat(roomId);
         const roomInfo = {
           roomId,
@@ -611,26 +692,41 @@ var TikTokLive = class extends EventEmitter {
         };
         this.emit("connected");
         this.emit("roomInfo", roomInfo);
-        resolve();
-      });
-      this.ws.on("message", (rawData) => {
-        this.handleFrame(Buffer.from(rawData));
-      });
-      this.ws.on("close", (code, reason) => {
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      };
+      ws.onmessage = (event) => {
+        const raw = event.data !== void 0 ? event.data : event;
+        this.handleMessage(raw);
+      };
+      ws.onclose = (event) => {
         this._connected = false;
         this.stopHeartbeat();
-        const reasonStr = reason?.toString() || "";
-        this.emit("disconnected", code, reasonStr);
+        const code = event?.code ?? 1006;
+        const reason = event?.reason ?? "";
+        this.emit("disconnected", code, reason?.toString?.() || "");
         if (!this.intentionalClose && this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
           this.reconnectAttempts++;
           const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), 3e4);
           setTimeout(() => this.connect().catch((e) => this.emit("error", e)), delay);
         }
-      });
-      this.ws.on("error", (err) => {
-        this.emit("error", err);
-        if (!this._connected) reject(err);
-      });
+      };
+      ws.onerror = (err) => {
+        this.emit("error", err instanceof Error ? err : new Error(String(err?.message || err)));
+        if (!settled) {
+          settled = true;
+          reject(err);
+        }
+      };
+      setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          ws.close();
+          reject(new Error("Connection timeout"));
+        }
+      }, 15e3);
     });
   }
   disconnect() {
@@ -651,6 +747,7 @@ var TikTokLive = class extends EventEmitter {
   get roomId() {
     return this._roomId;
   }
+  // Typed event emitter overrides
   on(event, listener) {
     return super.on(event, listener);
   }
@@ -663,6 +760,25 @@ var TikTokLive = class extends EventEmitter {
   emit(event, ...args) {
     return super.emit(event, ...args);
   }
+  // ── Message handling ──────────────────────────────────────────────
+  async handleMessage(raw) {
+    try {
+      let bytes;
+      if (raw instanceof ArrayBuffer) {
+        bytes = new Uint8Array(raw);
+      } else if (raw instanceof Uint8Array) {
+        bytes = raw;
+      } else if (typeof Blob !== "undefined" && raw instanceof Blob) {
+        bytes = new Uint8Array(await raw.arrayBuffer());
+      } else if (raw?.buffer instanceof ArrayBuffer) {
+        bytes = new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
+      } else {
+        return;
+      }
+      this.handleFrame(bytes);
+    } catch {
+    }
+  }
   handleFrame(buf) {
     try {
       const fields = decodeProto(buf);
@@ -670,14 +786,15 @@ var TikTokLive = class extends EventEmitter {
       const id = idField ? idField.value : 0n;
       const type = getStr(fields, 7);
       const binary = getBytes(fields, 8);
-      if (id > 0n && this.ws?.readyState === WebSocket.OPEN) {
-        this.ws.send(buildAck(id));
+      if (id > 0n && this.ws && this.ws.readyState === 1) {
+        const ack = buildAck(id);
+        this.ws.send(ack.buffer.byteLength === ack.length ? ack.buffer : ack.buffer.slice(ack.byteOffset, ack.byteOffset + ack.byteLength));
       }
       if (type === "msg" && binary && binary.length > 0) {
         let inner = binary;
         if (inner.length > 2 && inner[0] === 31 && inner[1] === 139) {
           try {
-            inner = zlib.gunzipSync(inner);
+            inner = gunzipSync(inner);
           } catch {
           }
         }
@@ -715,8 +832,9 @@ var TikTokLive = class extends EventEmitter {
   startHeartbeat(roomId) {
     this.stopHeartbeat();
     this.heartbeatTimer = setInterval(() => {
-      if (this.ws?.readyState === WebSocket.OPEN) {
-        this.ws.send(buildHeartbeat(roomId));
+      if (this.ws && this.ws.readyState === 1) {
+        const hb = buildHeartbeat(roomId);
+        this.ws.send(hb.buffer.byteLength === hb.length ? hb.buffer : hb.buffer.slice(hb.byteOffset, hb.byteOffset + hb.byteLength));
       }
     }, this.heartbeatInterval);
   }