@tiktool/live 2.6.1 → 2.6.3

package/dist/index.js

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  TikTokCaptions: () => TikTokCaptions,
   TikTokLive: () => TikTokLive,
   getRanklist: () => getRanklist,
   getRegionalRanklist: () => getRegionalRanklist
@@ -335,8 +336,10 @@ function parseBattleTeamFromArmies(itemBuf) {
       const userBufs = getAllBytes(gf, 1);
       for (const ub of userBufs) {
         try {
+          const userFields = decodeProto(ub);
+          const individualScore = getInt(userFields, 2);
           const user = parseUser(ub);
-          users.push({ user, score: points });
+          users.push({ user, score: individualScore });
         } catch {
         }
       }
@@ -1167,6 +1170,447 @@ var TikTokLive = class extends import_events.EventEmitter {
   }
 };
 
+// src/captions.ts
+var import_events2 = require("events");
+var import_ws2 = __toESM(require("ws"));
+var FLV_TAG_AUDIO = 8;
+var FLV_HEADER_SIZE = 9;
+var FLV_PREV_TAG_SIZE = 4;
+var FlvAudioExtractor = class {
+  buffer = new Uint8Array(0);
+  headerParsed = false;
+  onAudio;
+  aacProfile = 2;
+  sampleRateIndex = 4;
+  channelConfig = 2;
+  ascParsed = false;
+  constructor(onAudio) {
+    this.onAudio = onAudio;
+  }
+  parseASC(asc) {
+    if (asc.length < 2) return;
+    this.aacProfile = asc[0] >> 3 & 31;
+    this.sampleRateIndex = (asc[0] & 7) << 1 | asc[1] >> 7 & 1;
+    this.channelConfig = asc[1] >> 3 & 15;
+    this.ascParsed = true;
+  }
+  buildAdtsHeader(frameLength) {
+    const adts = new Uint8Array(7);
+    const fullLength = frameLength + 7;
+    const profile = this.aacProfile - 1;
+    adts[0] = 255;
+    adts[1] = 241;
+    adts[2] = (profile & 3) << 6 | (this.sampleRateIndex & 15) << 2 | this.channelConfig >> 2 & 1;
+    adts[3] = (this.channelConfig & 3) << 6 | fullLength >> 11 & 3;
+    adts[4] = fullLength >> 3 & 255;
+    adts[5] = (fullLength & 7) << 5 | 31;
+    adts[6] = 252;
+    return adts;
+  }
+  push(chunk) {
+    const newBuf = new Uint8Array(this.buffer.length + chunk.length);
+    newBuf.set(this.buffer, 0);
+    newBuf.set(chunk, this.buffer.length);
+    this.buffer = newBuf;
+    if (!this.headerParsed) {
+      if (this.buffer.length < FLV_HEADER_SIZE + FLV_PREV_TAG_SIZE) return;
+      if (this.buffer[0] !== 70 || this.buffer[1] !== 76 || this.buffer[2] !== 86) return;
+      const dv = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+      const dataOffset = dv.getUint32(5);
+      this.buffer = this.buffer.subarray(dataOffset + FLV_PREV_TAG_SIZE);
+      this.headerParsed = true;
+    }
+    while (this.buffer.length >= 11) {
+      const tagType = this.buffer[0] & 31;
+      const dataSize = this.buffer[1] << 16 | this.buffer[2] << 8 | this.buffer[3];
+      const totalTagSize = 11 + dataSize + FLV_PREV_TAG_SIZE;
+      if (this.buffer.length < totalTagSize) break;
+      if (tagType === FLV_TAG_AUDIO) {
+        const audioData = this.buffer.subarray(11, 11 + dataSize);
+        if (audioData.length > 0) {
+          const soundFormat = audioData[0] >> 4 & 15;
+          if (soundFormat === 10 && audioData.length > 2) {
+            const aacPacketType = audioData[1];
+            if (aacPacketType === 0) {
+              this.parseASC(audioData.subarray(2));
+            } else if (aacPacketType === 1 && this.ascParsed) {
+              const rawFrame = audioData.subarray(2);
+              const adtsHeader = this.buildAdtsHeader(rawFrame.length);
+              const adtsFrame = new Uint8Array(adtsHeader.length + rawFrame.length);
+              adtsFrame.set(adtsHeader, 0);
+              adtsFrame.set(rawFrame, adtsHeader.length);
+              this.onAudio(adtsFrame);
+            }
+          }
+        }
+      }
+      this.buffer = this.buffer.subarray(totalTagSize);
+    }
+  }
+  reset() {
+    this.buffer = new Uint8Array(0);
+    this.headerParsed = false;
+    this.ascParsed = false;
+  }
+};
+var DEFAULT_CAPTIONS_SERVER = "wss://api.tik.tools";
+var TikTokCaptions = class extends import_events2.EventEmitter {
+  ws = null;
+  _connected = false;
+  intentionalClose = false;
+  reconnectAttempts = 0;
+  uniqueId;
+  apiKey;
+  serverUrl;
+  autoReconnect;
+  maxReconnectAttempts;
+  debug;
+  _translate;
+  _diarization;
+  _maxDurationMinutes;
+  _language;
+  streamAbortController = null;
+  flvExtractor = null;
+  streamUrl = null;
+  constructor(options) {
+    super();
+    this.uniqueId = options.uniqueId.replace(/^@/, "");
+    if (!options.apiKey) throw new Error("apiKey is required. Get a free key at https://tik.tools");
+    this.apiKey = options.apiKey;
+    this._language = options.language || "";
+    this._translate = options.translate || "";
+    this._diarization = options.diarization ?? true;
+    this._maxDurationMinutes = options.maxDurationMinutes ?? 60;
+    this.serverUrl = (options.signServerUrl || DEFAULT_CAPTIONS_SERVER).replace(/\/$/, "");
+    this.autoReconnect = options.autoReconnect ?? true;
+    this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+    this.debug = options.debug ?? false;
+  }
+  /**
+   * Start real-time captions for the configured TikTok user.
+   * Connects to the captions WebSocket relay and begins transcription
+   * once the user goes live (or immediately if already live).
+   */
+  async start() {
+    this.intentionalClose = false;
+    const wsUrl = this.buildWsUrl();
+    if (this.debug) console.log(`[Captions] Connecting to ${wsUrl}`);
+    return new Promise((resolve, reject) => {
+      this.ws = new import_ws2.default(wsUrl);
+      this.ws.on("open", () => {
+        this._connected = true;
+        this.reconnectAttempts = 0;
+        if (this.debug) console.log("[Captions] Connected");
+        this.emit("connected");
+        resolve();
+      });
+      this.ws.on("message", (data) => {
+        this.handleMessage(typeof data === "string" ? data : data.toString());
+      });
+      this.ws.on("close", (code, reason) => {
+        this._connected = false;
+        const reasonStr = reason?.toString() || "";
+        if (this.debug) console.log(`[Captions] Disconnected: ${code} ${reasonStr}`);
+        this.emit("disconnected", code, reasonStr);
+        if (!this.intentionalClose && this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+          this.reconnectAttempts++;
+          const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), 3e4);
+          if (this.debug) console.log(`[Captions] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+          setTimeout(() => this.start().catch((e) => this.emit("error", { code: "RECONNECT_FAILED", message: e.message })), delay);
+        }
+      });
+      this.ws.on("error", (err) => {
+        this.emit("error", { code: "WS_ERROR", message: err.message });
+        if (!this._connected) reject(err);
+      });
+    });
+  }
+  /**
+   * Stop captions and disconnect.
+   */
+  stop() {
+    this.intentionalClose = true;
+    if (this.streamAbortController) {
+      this.streamAbortController.abort();
+      this.streamAbortController = null;
+    }
+    if (this.flvExtractor) {
+      this.flvExtractor.reset();
+      this.flvExtractor = null;
+    }
+    if (this.ws) {
+      this.send({ action: "stop" });
+      this.ws.close(1e3);
+      this.ws = null;
+    }
+    this._connected = false;
+  }
+  /**
+   * Switch the translation target language on-the-fly.
+   * Causes a brief interruption while the transcription engine reconfigures.
+   */
+  setLanguage(language) {
+    this._language = language;
+    this.send({ action: "set_language", language });
+  }
+  /**
+   * Request a credit balance update from the server.
+   */
+  getCredits() {
+    this.send({ action: "get_credits" });
+  }
+  /** Whether the WebSocket is currently connected */
+  get connected() {
+    return this._connected;
+  }
+  /** The current target language */
+  get language() {
+    return this._language;
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  buildWsUrl() {
+    const base = this.serverUrl.replace(/^http/, "ws");
+    const params = new URLSearchParams({
+      uniqueId: this.uniqueId,
+      apiKey: this.apiKey
+    });
+    if (this._language) params.set("language", this._language);
+    if (this._translate) params.set("translate", this._translate);
+    if (this._diarization !== void 0) params.set("diarization", String(this._diarization));
+    if (this._maxDurationMinutes) params.set("max_duration_minutes", String(this._maxDurationMinutes));
+    return `${base}/captions?${params}`;
+  }
+  send(msg) {
+    if (this.ws?.readyState === import_ws2.default.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  handleMessage(raw) {
+    try {
+      const msg = JSON.parse(raw);
+      switch (msg.type) {
+        case "stream_info":
+          if (this.debug) console.log(`[Captions] Received stream_info: flv=${!!msg.flvUrl}, hls=${!!msg.hlsUrl}, ao=${!!msg.audioOnlyUrl}`);
+          this.connectToStream(msg);
+          break;
+        case "caption":
+          this.emit("caption", {
+            text: msg.text,
+            language: msg.language,
+            isFinal: msg.isFinal,
+            confidence: msg.confidence,
+            speaker: msg.speaker,
+            startMs: msg.startMs,
+            endMs: msg.endMs
+          });
+          break;
+        case "translation":
+          this.emit("translation", {
+            text: msg.text,
+            language: msg.language,
+            isFinal: msg.isFinal,
+            confidence: msg.confidence,
+            speaker: msg.speaker
+          });
+          break;
+        case "status":
+          this.emit("status", {
+            status: msg.status,
+            uniqueId: msg.uniqueId,
+            roomId: msg.roomId,
+            language: msg.language,
+            message: msg.message
+          });
+          break;
+        case "credits":
+          this.emit("credits", {
+            remaining: msg.remaining,
+            total: msg.total,
+            used: msg.used,
+            warning: msg.warning
+          });
+          break;
+        case "credits_low":
+          this.emit("credits_low", {
+            remaining: msg.remaining,
+            total: msg.total,
+            percent: msg.percent
+          });
+          break;
+        case "error":
+          this.emit("error", {
+            code: msg.code,
+            message: msg.message
+          });
+          break;
+        // Handle interim/final captions from server (sentence-level accumulation)
+        case "interim":
+          this.emit("caption", {
+            text: msg.text,
+            language: msg.language,
+            isFinal: false,
+            confidence: msg.confidence || 0,
+            speaker: msg.speaker
+          });
+          break;
+        case "final":
+          this.emit("caption", {
+            text: msg.text,
+            language: msg.language,
+            isFinal: true,
+            confidence: msg.confidence || 0,
+            speaker: msg.speaker
+          });
+          break;
+        case "translation_interim":
+          this.emit("translation", {
+            text: msg.text,
+            language: msg.language,
+            isFinal: false,
+            confidence: msg.confidence || 0,
+            speaker: msg.speaker
+          });
+          break;
+        case "translation_final":
+          this.emit("translation", {
+            text: msg.text,
+            language: msg.language,
+            isFinal: true,
+            confidence: msg.confidence || 0,
+            speaker: msg.speaker
+          });
+          break;
+        default:
+          if (this.debug) {
+            console.log(`[Captions] Unknown message type: ${msg.type}`, msg);
+          }
+      }
+    } catch {
+      if (this.debug) console.error("[Captions] Failed to parse message:", raw);
+    }
+  }
+  /**
+   * Connect to the TikTok FLV stream and extract audio.
+   * Sends binary audio buffers to the server via WebSocket.
+   */
+  async connectToStream(streamInfo) {
+    const url = streamInfo.audioOnlyUrl || streamInfo.flvUrl;
+    if (!url) {
+      this.emit("error", { code: "NO_STREAM_URL", message: "Server did not provide a usable stream URL" });
+      return;
+    }
+    this.streamUrl = url;
+    if (this.debug) console.log(`[Captions] connectToStream: URL selected: ${url.substring(0, 80)}...`);
+    if (this.streamAbortController) {
+      this.streamAbortController.abort();
+    }
+    this.streamAbortController = new AbortController();
+    let audioFramesSent = 0;
+    let audioBytesSent = 0;
+    this.flvExtractor = new FlvAudioExtractor((adtsFrame) => {
+      if (this.ws?.readyState === import_ws2.default.OPEN) {
+        this.ws.send(adtsFrame);
+        audioFramesSent++;
+        audioBytesSent += adtsFrame.length;
+        if (this.debug && (audioFramesSent <= 3 || audioFramesSent % 100 === 0)) {
+          console.log(`[Captions] Audio frame #${audioFramesSent}: ${adtsFrame.length}b (total: ${audioBytesSent}b)`);
+        }
+      } else if (this.debug && audioFramesSent === 0) {
+        console.log(`[Captions] WARNING: WS not open (readyState=${this.ws?.readyState}), cannot send audio`);
+      }
+    });
+    try {
+      if (this.debug) console.log(`[Captions] connectToStream: calling fetch()...`);
+      const resp = await fetch(url, {
+        signal: this.streamAbortController.signal,
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        }
+      });
+      if (this.debug) console.log(`[Captions] connectToStream: fetch returned status=${resp.status}, hasBody=${!!resp.body}`);
+      if (!resp.ok || !resp.body) {
+        throw new Error(`FLV stream HTTP ${resp.status}`);
+      }
+      if (this.debug) console.log(`[Captions] FLV stream connected (${resp.status})`);
+      const reader = resp.body.getReader ? resp.body.getReader() : null;
+      if (this.debug) console.log(`[Captions] connectToStream: hasReader=${!!reader}, hasAsyncIterator=${typeof resp.body[Symbol.asyncIterator] === "function"}`);
+      if (reader) {
+        const processStream = async () => {
+          let chunks = 0;
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done || this.intentionalClose) {
+                if (this.debug) console.log(`[Captions] FLV stream ended (done=${done}, intentionalClose=${this.intentionalClose}), chunks=${chunks}, audioFrames=${audioFramesSent}`);
+                break;
+              }
+              chunks++;
+              if (value && this.flvExtractor) {
+                this.flvExtractor.push(value);
+              }
+              if (this.debug && chunks <= 3) {
+                console.log(`[Captions] FLV chunk #${chunks}: ${value?.length || 0}b`);
+              }
+            }
+          } catch (err) {
+            if (err.name !== "AbortError" && !this.intentionalClose) {
+              if (this.debug) console.error("[Captions] FLV stream read error:", err.message);
+              this.emit("error", { code: "STREAM_READ_ERROR", message: err.message });
+            } else if (this.debug) {
+              console.log(`[Captions] FLV stream aborted after ${chunks} chunks, ${audioFramesSent} audio frames`);
+            }
+          }
+        };
+        processStream();
+      } else if (typeof resp.body[Symbol.asyncIterator] === "function") {
+        const processNodeStream = async () => {
+          let chunks = 0;
+          try {
+            for await (const chunk of resp.body) {
+              if (this.intentionalClose) break;
+              chunks++;
+              const u8 = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+              if (this.flvExtractor) {
+                this.flvExtractor.push(u8);
+              }
+              if (this.debug && chunks <= 3) {
+                console.log(`[Captions] FLV chunk #${chunks}: ${u8.length}b`);
+              }
+            }
+            if (this.debug) console.log(`[Captions] Node stream ended, chunks=${chunks}, audioFrames=${audioFramesSent}`);
+          } catch (err) {
+            if (err.name !== "AbortError" && !this.intentionalClose) {
+              if (this.debug) console.error("[Captions] FLV stream read error:", err.message);
+              this.emit("error", { code: "STREAM_READ_ERROR", message: err.message });
+            } else if (this.debug) {
+              console.log(`[Captions] FLV node stream aborted after ${chunks} chunks, ${audioFramesSent} audio frames`);
+            }
+          }
+        };
+        processNodeStream();
+      } else {
+        if (this.debug) console.error(`[Captions] ERROR: resp.body has no getReader() and no asyncIterator!`);
+      }
+    } catch (err) {
+      if (err.name !== "AbortError" && !this.intentionalClose) {
+        console.error("[Captions] FLV stream connect error:", err.message);
+        this.emit("error", { code: "STREAM_CONNECT_ERROR", message: err.message });
+      }
+    }
+  }
+};
+
 // src/api.ts
 var DEFAULT_SIGN_SERVER2 = "https://api.tik.tools";
 var PAGE_CACHE_TTL = 5 * 60 * 1e3;
@@ -1224,6 +1668,7 @@ async function getRegionalRanklist(opts) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  TikTokCaptions,
   TikTokLive,
   getRanklist,
   getRegionalRanklist