@tiktool/live 2.6.2 → 2.6.3

package/dist/index.d.mts

@@ -567,6 +567,9 @@ declare class TikTokCaptions extends EventEmitter {
     private readonly _diarization;
     private readonly _maxDurationMinutes;
     private _language;
+    private streamAbortController;
+    private flvExtractor;
+    private streamUrl;
     constructor(options: TikTokCaptionsOptions);
     /**
      * Start real-time captions for the configured TikTok user.
@@ -598,6 +601,11 @@ declare class TikTokCaptions extends EventEmitter {
     private buildWsUrl;
     private send;
     private handleMessage;
+    /**
+     * Connect to the TikTok FLV stream and extract audio.
+     * Sends binary audio buffers to the server via WebSocket.
+     */
+    private connectToStream;
 }
 
 interface GetRanklistOptions {

package/dist/index.d.ts

@@ -567,6 +567,9 @@ declare class TikTokCaptions extends EventEmitter {
     private readonly _diarization;
     private readonly _maxDurationMinutes;
     private _language;
+    private streamAbortController;
+    private flvExtractor;
+    private streamUrl;
     constructor(options: TikTokCaptionsOptions);
     /**
      * Start real-time captions for the configured TikTok user.
@@ -598,6 +601,11 @@ declare class TikTokCaptions extends EventEmitter {
     private buildWsUrl;
     private send;
     private handleMessage;
+    /**
+     * Connect to the TikTok FLV stream and extract audio.
+     * Sends binary audio buffers to the server via WebSocket.
+     */
+    private connectToStream;
 }
 
 interface GetRanklistOptions {

package/dist/index.js

@@ -1173,6 +1173,86 @@ 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;
@@ -1189,6 +1269,9 @@ var TikTokCaptions = class extends import_events2.EventEmitter {
   _diarization;
   _maxDurationMinutes;
   _language;
+  streamAbortController = null;
+  flvExtractor = null;
+  streamUrl = null;
   constructor(options) {
     super();
     this.uniqueId = options.uniqueId.replace(/^@/, "");
@@ -1247,6 +1330,14 @@ var TikTokCaptions = class extends import_events2.EventEmitter {
    */
   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);
@@ -1309,6 +1400,10 @@ var TikTokCaptions = class extends import_events2.EventEmitter {
     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,
@@ -1359,6 +1454,43 @@ var TikTokCaptions = class extends import_events2.EventEmitter {
             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);
@@ -1368,6 +1500,115 @@ var TikTokCaptions = class extends import_events2.EventEmitter {
       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