@tiktool/live 2.6.2 → 2.6.4

package/dist/index.mjs

@@ -1134,6 +1134,86 @@ var TikTokLive = class extends EventEmitter {
 // src/captions.ts
 import { EventEmitter as EventEmitter2 } from "events";
 import WebSocket2 from "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 EventEmitter2 {
   ws = null;
@@ -1150,6 +1230,9 @@ var TikTokCaptions = class extends EventEmitter2 {
   _diarization;
   _maxDurationMinutes;
   _language;
+  streamAbortController = null;
+  flvExtractor = null;
+  streamUrl = null;
   constructor(options) {
     super();
     this.uniqueId = options.uniqueId.replace(/^@/, "");
@@ -1208,6 +1291,14 @@ var TikTokCaptions = class extends EventEmitter2 {
    */
   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);
@@ -1270,6 +1361,10 @@ var TikTokCaptions = class extends EventEmitter2 {
     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,
@@ -1320,15 +1415,161 @@ var TikTokCaptions = class extends EventEmitter2 {
             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);
+            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 === WebSocket2.OPEN) {
+        this.ws.send(adtsFrame);
+        audioFramesSent++;
+        audioBytesSent += adtsFrame.length;
+        if (this.debug && (audioFramesSent <= 3 || audioFramesSent % 100 === 0)) {
+          if (this.debug) console.log(`[Captions] Audio frame #${audioFramesSent}: ${adtsFrame.length}b (total: ${audioBytesSent}b)`);
+        }
+      } else if (this.debug && audioFramesSent === 0) {
+        if (this.debug) 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) {
+                if (this.debug) 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) {
+              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) {
+                if (this.debug) 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) {
+              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) {
+        if (this.debug) console.error("[Captions] FLV stream connect error:", err.message);
+        this.emit("error", { code: "STREAM_CONNECT_ERROR", message: err.message });
+      }
+    }
+  }
 };
 
 // src/api.ts
@@ -1386,9 +1627,46 @@ async function getRegionalRanklist(opts) {
   }
   return data;
 }
+async function getLiveFeed(opts) {
+  const base = (opts.serverUrl || DEFAULT_SIGN_SERVER2).replace(/\/$/, "");
+  const params = new URLSearchParams();
+  params.set("apiKey", opts.apiKey);
+  if (opts.region) params.set("region", opts.region);
+  if (opts.channelId) params.set("channel_id", opts.channelId);
+  if (opts.count !== void 0) params.set("count", String(Math.min(opts.count, 50)));
+  if (opts.maxTime) params.set("max_time", opts.maxTime);
+  if (opts.sessionId) params.set("session_id", opts.sessionId);
+  if (opts.ttwid) params.set("ttwid", opts.ttwid);
+  if (opts.msToken) params.set("ms_token", opts.msToken);
+  const resp = await fetch(`${base}/webcast/feed?${params.toString()}`);
+  const data = await resp.json();
+  if (resp.status === 429) {
+    throw new Error(data.error || "Feed daily limit reached. Upgrade your plan for more calls.");
+  }
+  if (!resp.ok) {
+    throw new Error(data.error || `Feed request failed (HTTP ${resp.status})`);
+  }
+  return data;
+}
+async function fetchFeed(opts) {
+  const signed = await getLiveFeed(opts);
+  const headers = { ...signed.headers || {} };
+  if (signed.cookies) {
+    headers["Cookie"] = signed.cookies;
+  }
+  const resp = await fetch(signed.signed_url, { headers, redirect: "follow" });
+  const text = await resp.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
 export {
   TikTokCaptions,
   TikTokLive,
+  fetchFeed,
+  getLiveFeed,
   getRanklist,
   getRegionalRanklist
 };