@tiktool/live 2.6.1 → 2.6.2

package/dist/index.mjs

@@ -297,8 +297,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 {
         }
       }
@@ -1129,6 +1131,206 @@ var TikTokLive = class extends EventEmitter {
   }
 };
 
+// src/captions.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import WebSocket2 from "ws";
+var DEFAULT_CAPTIONS_SERVER = "wss://api.tik.tools";
+var TikTokCaptions = class extends EventEmitter2 {
+  ws = null;
+  _connected = false;
+  intentionalClose = false;
+  reconnectAttempts = 0;
+  uniqueId;
+  apiKey;
+  serverUrl;
+  autoReconnect;
+  maxReconnectAttempts;
+  debug;
+  _translate;
+  _diarization;
+  _maxDurationMinutes;
+  _language;
+  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 WebSocket2(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.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 === WebSocket2.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  handleMessage(raw) {
+    try {
+      const msg = JSON.parse(raw);
+      switch (msg.type) {
+        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;
+        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);
+    }
+  }
+};
+
 // src/api.ts
 var DEFAULT_SIGN_SERVER2 = "https://api.tik.tools";
 var PAGE_CACHE_TTL = 5 * 60 * 1e3;
@@ -1185,6 +1387,7 @@ async function getRegionalRanklist(opts) {
   return data;
 }
 export {
+  TikTokCaptions,
   TikTokLive,
   getRanklist,
   getRegionalRanklist