@vanzxy/baileys 2.0.0

package/lib/VoIP/audio-feeder.js

@@ -0,0 +1,132 @@
+/**
+ * Audio feeder.
+ *
+ * Spawns ffmpeg to decode `source` into f32le PCM at the requested rate, then
+ * meters frames out at chunk-cadence to the WASM uplink.
+ *
+ * @author ShellTear
+ */
+import { spawn } from "node:child_process";
+const LOW_WATERMARK_CHUNKS = 16;
+const MAX_QUEUED_CHUNKS = 1024;
+const DEFAULT_WARMUP_MS = 500;
+export class AudioFeeder {
+    sampleRate;
+    channels;
+    framesPerChunk;
+    onChunk;
+    source;
+    #proc = null;
+    #pending = Buffer.alloc(0);
+    #queue = [];
+    #emitTimer = null;
+    #nextEmitAtMs = 0;
+    #warmupUntilMs = 0;
+    droppedChunks = 0;
+    underflowChunks = 0;
+    bytesProduced = 0;
+    chunksEmitted = 0;
+    constructor(sampleRate, channels, framesPerChunk, onChunk, source = "silence") {
+        this.sampleRate = sampleRate;
+        this.channels = channels;
+        this.framesPerChunk = framesPerChunk;
+        this.onChunk = onChunk;
+        this.source = source;
+    }
+    start = () => {
+        if (this.#proc)
+            return;
+        const chunkSamples = this.framesPerChunk * this.channels;
+        const chunkBytes = chunkSamples * Float32Array.BYTES_PER_ELEMENT;
+        const chunkIntervalMs = (this.framesPerChunk / this.sampleRate) * 1000;
+        const inputArgs = this.#resolveInputArgs();
+        this.#proc = spawn("ffmpeg", [
+            "-hide_banner",
+            "-loglevel", "error",
+            "-thread_queue_size", "512",
+            ...inputArgs,
+            "-f", "f32le",
+            "-ac", String(this.channels),
+            "-ar", String(this.sampleRate),
+            "pipe:1",
+        ]);
+        this.#proc.stdout.on("data", (chunk) => {
+            this.#pending = Buffer.concat([this.#pending, chunk]);
+            while (this.#pending.length >= chunkBytes) {
+                if (this.#queue.length >= MAX_QUEUED_CHUNKS) {
+                    this.#proc?.stdout.pause();
+                    break;
+                }
+                const frame = this.#pending.subarray(0, chunkBytes);
+                this.#pending = this.#pending.subarray(chunkBytes);
+                const out = new Float32Array(chunkSamples);
+                out.set(new Float32Array(frame.buffer, frame.byteOffset, chunkSamples));
+                this.bytesProduced += chunkBytes;
+                this.#queue.push(out);
+            }
+        });
+        this.#proc.stderr.on("data", (chunk) => {
+            process.stderr.write(`[AudioFeeder] ${chunk.toString().trim()}\n`);
+        });
+        this.#proc.on("exit", (code) => {
+            if (code !== 0 && code !== null) {
+                process.stderr.write(`[AudioFeeder] ffmpeg exited with code=${code}\n`);
+            }
+            this.#proc = null;
+        });
+        this.#nextEmitAtMs = 0;
+        this.#warmupUntilMs = Date.now() + DEFAULT_WARMUP_MS;
+        this.#scheduleNext(chunkSamples, chunkIntervalMs);
+    };
+    stop = () => {
+        if (this.#emitTimer) {
+            clearTimeout(this.#emitTimer);
+            this.#emitTimer = null;
+        }
+        this.#proc?.kill("SIGTERM");
+        this.#proc = null;
+        this.#pending = Buffer.alloc(0);
+        this.#queue = [];
+        this.#warmupUntilMs = 0;
+    };
+    #resolveInputArgs = () => {
+        if (!this.source || this.source === "silence") {
+            return ["-f", "lavfi", "-i", `aevalsrc=0:d=3600:s=${this.sampleRate}`];
+        }
+        if (this.source.startsWith("lavfi:")) {
+            return ["-f", "lavfi", "-i", this.source.slice("lavfi:".length)];
+        }
+        return ["-i", this.source];
+    };
+    #scheduleNext = (chunkSamples, chunkIntervalMs) => {
+        if (!this.#proc)
+            return;
+        const now = Date.now();
+        if (this.#nextEmitAtMs === 0)
+            this.#nextEmitAtMs = now;
+        const delayMs = Math.max(0, this.#nextEmitAtMs - now);
+        this.#emitTimer = setTimeout(() => {
+            this.#emitTimer = null;
+            if (this.#queue.length < LOW_WATERMARK_CHUNKS && Date.now() < this.#warmupUntilMs) {
+                this.#nextEmitAtMs = Date.now() + 10;
+                this.#scheduleNext(chunkSamples, chunkIntervalMs);
+                return;
+            }
+            this.#flushOne(chunkSamples);
+            this.#nextEmitAtMs += chunkIntervalMs;
+            this.#scheduleNext(chunkSamples, chunkIntervalMs);
+        }, delayMs);
+    };
+    #flushOne = (chunkSamples) => {
+        let nextChunk = this.#queue.shift();
+        if (!nextChunk) {
+            nextChunk = new Float32Array(chunkSamples);
+            this.underflowChunks += 1;
+        }
+        this.chunksEmitted += 1;
+        this.onChunk(nextChunk);
+        if (this.#proc?.stdout.isPaused() && this.#queue.length <= MAX_QUEUED_CHUNKS / 4) {
+            this.#proc.stdout.resume();
+        }
+    };
+}

package/lib/VoIP/index.js

@@ -0,0 +1,277 @@
+import { EventEmitter } from "node:events";
+import { randomBytes, createHmac } from "node:crypto";
+
+import { WasmEngine } from "./wasm-engine.js";
+import { RelayRtcTransport } from "./relay-transport.js";
+import { SignalingBridge } from "./signaling.js";
+import { AudioFeeder } from "./audio-feeder.js";
+import { CallState } from "./types.js";
+
+export { CallState } from "./types.js";
+
+const SHA256_LEN = 32;
+
+const toBareJid = (jid) => {
+  if (!jid) return jid;
+  const at = jid.indexOf("@");
+  if (at < 0) return jid;
+  const user = jid.slice(0, at).split(":")[0];
+  return `${user}@${jid.slice(at + 1)}`;
+};
+
+const computeHkdf = (key, salt, info, length) => {
+  const effectiveSalt = salt && salt.length > 0 ? Buffer.from(salt) : Buffer.alloc(SHA256_LEN, 0);
+  const prk = createHmac("sha256", effectiveSalt).update(key).digest();
+  const blocks = Math.ceil(length / SHA256_LEN);
+  const okm = Buffer.alloc(blocks * SHA256_LEN);
+  let prev = Buffer.alloc(0);
+  for (let i = 1; i <= blocks; i += 1) {
+    prev = createHmac("sha256", prk)
+      .update(prev)
+      .update(info)
+      .update(Buffer.from([i]))
+      .digest();
+    prev.copy(okm, (i - 1) * SHA256_LEN);
+  }
+  return new Uint8Array(okm.buffer, okm.byteOffset, length);
+};
+
+const computeHmacSha256 = (data, key) => {
+  const result = createHmac("sha256", Buffer.from(key)).update(data).digest();
+  return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+};
+
+const isCallReceiptNode = (node) => {
+  if (node?.tag !== "receipt") return false;
+  const child = Array.isArray(node.content) ? node.content[0] : null;
+  return !!(child?.attrs?.["call-id"] || child?.attrs?.call_id);
+};
+
+export class ActiveCall extends EventEmitter {
+  #state = CallState.Idle;
+  #endResolver;
+  #endPromise;
+  #endTimer = null;
+  #ended = false;
+  _audioSource = "silence";
+
+  constructor(callId, engine, durationMs) {
+    super();
+    this.callId = callId;
+    this.engine = engine;
+    this.#endPromise = new Promise((res) => { this.#endResolver = res; });
+    if (durationMs > 0) {
+      this.#endTimer = setTimeout(() => this.end(), durationMs);
+    }
+  }
+
+  get state() { return this.#state; }
+
+  end = () => {
+    if (this.#ended) return;
+    this.#ended = true;
+    if (this.#endTimer) { clearTimeout(this.#endTimer); this.#endTimer = null; }
+    try { this.engine.endCall(0, true); } catch {}
+  };
+
+  mute = (muted) => {
+    try { this.engine.setMute(muted); } catch {}
+  };
+
+  waitForEnd = () => this.#endPromise;
+
+  _updateState = (state) => {
+    this.#state = state;
+    if (state === CallState.PreacceptReceived) this.emit("ringing");
+    else if (state === CallState.Active) this.emit("connected");
+    else if (state === CallState.Idle || state === CallState.Ending) {
+      this._forceEnd("ended");
+    }
+  };
+
+  _emitAudio = (pcm) => { this.emit("audio", pcm); };
+
+  _forceEnd = (reason) => {
+    if (this.#ended) return;
+    this.#ended = true;
+    if (this.#endTimer) { clearTimeout(this.#endTimer); this.#endTimer = null; }
+    this.emit("ended", reason);
+    this.#endResolver(reason);
+  };
+}
+
+export class VoipClient {
+  #config;
+  #engine = null;
+  #relay = null;
+  #signaling = null;
+  #sock = null;
+  #activeCall = null;
+  #capturePtr = 0;
+  #captureChunkBytes = 0;
+  #captureSampleRate = 16000;
+  #captureChannels = 1;
+  #captureFramesPerChunk = 320;
+  #feeder = null;
+
+  constructor(config = {}) {
+    this.#config = config;
+  }
+
+  connectWithSocket = async (existingSock) => {
+    this.#sock = existingSock;
+    await this.#initVoipStack();
+  };
+
+  #initVoipStack = async () => {
+    this.#signaling = new SignalingBridge({ sock: this.#sock });
+    await this.#signaling.init();
+
+    this.#relay = new RelayRtcTransport({
+      onTransportMessage: (data, ip, port) => this.#engine?.handleOnTransportMessage(data, ip, port),
+      onIceRtt: (rttMs, ip, port) => this.#engine?.updateIceRtt(rttMs, ip, port),
+    });
+
+    this.#engine = new WasmEngine({
+      resourcesPath: this.#config.resourcesPath,
+      callbacks: {
+        onSignalingXmpp: (peerJid, callId, xmlPayload) =>
+          this.#signaling.sendSignaling(peerJid, callId, xmlPayload),
+        onCallEvent: (eventType, eventData) => this.#handleCallEvent(eventType, eventData),
+        sendDataToRelay: (data, ip, port) => this.#relay.send(data, ip, port),
+        onAudioCaptureInit: (config) => this.#handleAudioCaptureInit(config),
+        onAudioCaptureStart: () => this.#handleAudioCaptureStart(),
+        onAudioCaptureStop: () => this.#handleAudioCaptureStop(),
+        onAudioPlaybackData: (audioData) => this.#activeCall?._emitAudio(audioData),
+        cryptoHkdf: computeHkdf,
+        hmacSha256: computeHmacSha256,
+      },
+    });
+
+    await this.#engine.initialize();
+    this.#signaling.attachEngine(this.#engine);
+
+    const selfPnJid = this.#sock.authState.creds.me?.id;
+    const selfLidJid = this.#sock.authState.creds.me?.lid;
+    this.#engine.initVoipStack(selfPnJid, toBareJid(selfPnJid), selfLidJid);
+    await this.#engine.waitForVoipStackReady();
+    try { this.#engine.updateNetworkMedium(2, 0); } catch {}
+
+    this.#sock.ws.on("CB:call", (node) => {
+      this.#signaling.processIncomingCall(node, this.#engine, this.#activeCall?.callId ?? "");
+    });
+    this.#sock.ws.on("CB:receipt", (node) => {
+      if (!isCallReceiptNode(node)) return;
+      this.#signaling.processIncomingReceipt(node, this.#engine, this.#activeCall?.callId ?? "");
+    });
+  };
+
+  call = async (phoneNumber, opts = {}) => {
+    if (!this.#engine || !this.#signaling) throw new Error("Not connected. Call connectWithSocket() first.");
+    if (this.#activeCall) throw new Error("A call is already active.");
+
+    const targetNumber = phoneNumber.replace(/\D/g, "");
+    const targetPnJid = `${targetNumber}@s.whatsapp.net`;
+    const durationMs = opts.durationMs ?? 120_000;
+    const audioSource = opts.audioSource ?? "silence";
+
+    const peerLid = await this.#signaling.resolveLid(targetPnJid);
+    if (!peerLid) throw new Error(`Could not resolve LID for ${targetPnJid}`);
+
+    for (const jid of [targetPnJid, peerLid]) {
+      try { await this.#sock.presenceSubscribe(jid); } catch {}
+    }
+    await new Promise((r) => setTimeout(r, 750));
+
+    const peerDeviceJids = await this.#signaling.discoverPeerDevices(peerLid);
+    const deviceList = peerDeviceJids.length ? peerDeviceJids : [toBareJid(peerLid)];
+
+    await this.#signaling.ensureSessionsForPeers(deviceList);
+
+    await new Promise((r) => setTimeout(r, 500));
+    await this.#signaling.issueTcToken(peerLid);
+    const tcToken = await this.#signaling.ensureTcToken(peerLid, targetPnJid);
+
+    const callId = ("00" + randomBytes(16).toString("hex").slice(2)).toUpperCase();
+
+    const call = new ActiveCall(callId, this.#engine, durationMs);
+    call._audioSource = audioSource;
+    this.#activeCall = call;
+
+    this.#engine.startCall({
+      peerJid: peerLid,
+      peerPn: targetPnJid,
+      peerList: deviceList,
+      callId,
+      isVideo: false,
+      isLidCall: true,
+      isFromDialer: false,
+      extraData: tcToken,
+    });
+
+    return call;
+  };
+
+  disconnect = () => {
+    this.#activeCall?._forceEnd("disconnect");
+    this.#activeCall = null;
+    this.#relay?.closeAll();
+    this.#engine?.destroy();
+    this.#engine = null;
+    this.#relay = null;
+    this.#signaling = null;
+    this.#sock = null;
+  };
+
+  #handleCallEvent = (eventType, eventData) => {
+    if (eventType === 16 && eventData) {
+      try {
+        const parsed = JSON.parse(eventData);
+        const info = parsed.call_info ?? parsed.callInfo ?? {};
+        const callState = Number(info.call_state ?? info.callState ?? 0);
+        this.#activeCall?._updateState(callState);
+      } catch {}
+    } else if (eventType === 156 && eventData) {
+      try {
+        const update = JSON.parse(eventData);
+        this.#relay?.updateRelayList(update);
+      } catch {}
+    } else if (eventType === 2) {
+      this.#activeCall?._forceEnd("remote_end");
+    }
+  };
+
+  #handleAudioCaptureInit = (config) => {
+    if (!this.#engine) return;
+    this.#captureSampleRate = config.sampleRate || 16000;
+    this.#captureChannels = config.channels || 1;
+    this.#captureFramesPerChunk = config.framesPerChunk || 320;
+    const chunkSamples = this.#captureFramesPerChunk * this.#captureChannels;
+    this.#captureChunkBytes = chunkSamples * Float32Array.BYTES_PER_ELEMENT;
+    this.#capturePtr = this.#engine.malloc(this.#captureChunkBytes);
+  };
+
+  #handleAudioCaptureStart = () => {
+    if (!this.#engine || !this.#capturePtr) return;
+    const audioSource = this.#activeCall?._audioSource ?? "silence";
+    this.#feeder = new AudioFeeder(
+      this.#captureSampleRate,
+      this.#captureChannels,
+      this.#captureFramesPerChunk,
+      (chunk) => {
+        if (this.#engine && this.#capturePtr) this.#engine.sendAudioData(chunk, this.#capturePtr);
+      },
+      audioSource,
+    );
+    this.#feeder.start();
+  };
+
+  #handleAudioCaptureStop = () => {
+    this.#feeder?.stop();
+    this.#feeder = null;
+    if (this.#engine && this.#capturePtr) {
+      try { this.#engine.free(this.#capturePtr); } catch {}
+      this.#capturePtr = 0;
+    }
+  };
+}

package/lib/VoIP/relay-transport.d.ts

@@ -0,0 +1,43 @@
+type RelayAddress = {
+    protocol: number;
+    ipv4?: string;
+    ipv6?: string;
+    port?: number;
+    port_v6?: number;
+};
+type RelayDescriptor = {
+    relay_id: number;
+    relay_name: string;
+    token_id: number;
+    auth_token_id?: number;
+    addresses: RelayAddress[];
+};
+export type RelayListUpdatePayload = {
+    relay_key: string;
+    relay_tokens: string[];
+    auth_tokens?: string[];
+    enable_edgeray_dtls_active_mode?: boolean;
+    relays: RelayDescriptor[];
+};
+export type RelayTransportStats = {
+    sentPackets: number;
+    receivedPackets: number;
+    sentBytes: number;
+    receivedBytes: number;
+    droppedPackets: number;
+    openConnections: number;
+};
+export type RelayTransportConfig = {
+    onTransportMessage: (data: Uint8Array, ip: string, port: number) => void;
+    onIceRtt?: (rttMs: number, ip: string, port: number) => void;
+};
+export declare class RelayRtcTransport {
+    #private;
+    private readonly config;
+    constructor(config: RelayTransportConfig);
+    updateRelayList: (update: RelayListUpdatePayload) => void;
+    send: (packet: Uint8Array | Buffer, ip: string, port: number) => number;
+    getStats: () => RelayTransportStats;
+    closeAll: () => Promise<void>;
+}
+export {};