@vanzxysenpai/baileys 0.0.1 → 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+## 0.0.2
+
+### Added
+- Experimental audio voice calls (`VoipClient`, `ActiveCall`, `CallState`; WASM call stack + WebRTC relay ported from ourin-baileys 9.0.11). Opt-in, needs the optional `@roamhq/wrtc` peer dependency.
+- Startup banner (`VanzxyBanner.js`): printed once per process on import and via the `prestart` script; opt out with `VANZXY_BANNER=0` (also respects `NO_COLOR`, plain text when not a TTY).
+
+### Changed
+- Repository links now point to `github.com/vanzxysenpai/vanzxysenpai`.
+- Removed internal change-log style code comments (third-party attribution headers are kept).
+- VoIP only runs when you create a `VoipClient`; there are still no connect-time account actions.
+
+## 0.0.1
+
+First release of `@vanzxysenpai/baileys`, built on WhiskeySockets/Baileys 7.0.0-rc14.
+
+### Included
+- rc14 core plus the `albumParentKey` send option.
+- Message builders (`AIRich`, `Button`/`ButtonV2`/`ButtonV3`, `Carousel`, `Poll`, `Album`, `Event`, `A2UI`), interactive / native-flow send layer, group status, newsletter / username / status extras, stickerpacks, `Bot` framework.
+- Merged `WAProto` containing every message class and field found in rc14 and newer community protos, with type declarations.
+- Stability and security helpers: reconnect backoff, Bad MAC handler, connection watchdog, auto-reconnect, encrypted auth state, SQLite / Mongo / MySQL / PostgreSQL / Redis backends, anti force-close payload guard (`createAnchorGuard`).
+- Media helpers (`resizeImage`, `convertToOpusAudio`, `convertToWhatsAppVideo`, `getVideoThumbnail`, `probeMedia`, `getMp4Duration`), `TTLCache`, social link-preview helpers.
+
+### Behaviour notes
+- `useMultiFileAuthState` writes `creds.json` atomically and keeps `creds.json.bak`; a corrupt file is restored from the backup or moved aside as `creds.json.corrupt-*`.
+- No install-time scripts, no connect-time account actions, no hidden message attribution.
+- `profilePictureUrl` defaults to `'image'`; the tc-token is opt-in (`shouldIncludeTcToken`).
+- Android browser platform is not enabled (platform is always WEB).
+- `Message.pollResultSnapshotMessageV3` keeps the field number used by the bundled proto.

package/NOTICE.md

@@ -106,7 +106,7 @@ below was MIT-licensed at its source at the time it was ported.
 ### ourin-baileys ports
 - **Source:** ourin-baileys (version 9.0.11 for the VoIP stack, per this package's `lib/index.js`).
 - **Location in this package:**
-  - *(`lib/VoIP/` and the bundled WASM call engine from ourin-baileys 9.0.11 are NOT part of @vanzxysenpai/baileys 0.0.1.)*
+  - `lib/VoIP/`, `lib/assets/wasm/` — audio call WASM stack + WebRTC relay (the bundled `whatsapp.wasm`, ~9.8 MB, comes with this port; its redistribution terms follow the ourin-baileys package it was taken from). Opt-in: nothing runs unless a `VoipClient` is created.
   - `lib/Builders/AIRich.js` — the `ORich` no-op subclass of `AIRich`, kept only for drop-in compatibility with code originally written against ourin-baileys.
 
 ---

package/README.md

@@ -59,6 +59,7 @@
   - [Carousel](#carousel)
   - [AIRich — rich response cards](#airich--rich-response-cards)
   - [📁 Builders Folder Map](#-builders-folder-map-libbuilders)
+- [📞 Voice Calls (experimental)](#-voice-calls-experimental)
 - [🔎 User Sync Queries](#-user-sync-queries)
 - [👤 Username Management](#-username-management)
 - [🤖 Bot Framework](#-bot-framework)
@@ -85,6 +86,14 @@
 
 ---
 
+## Changelog 0.0.2
+
+- **Voice calls (experimental, opt-in):** `VoipClient`, `ActiveCall`, `CallState` — WASM call stack + WebRTC relay ported from ourin-baileys; needs the optional `@roamhq/wrtc` peer dependency.
+- **Startup banner:** `VanzxyBanner.js`, shown once per process; disable with `VANZXY_BANNER=0`.
+- **Cleanup:** repository links now point to `github.com/vanzxysenpai/vanzxysenpai`; internal change-log style code comments removed.
+
+---
+
 ## Changelog 0.0.1
 
 First release of **@vanzxysenpai/baileys**, built on top of WhiskeySockets/Baileys 7.0.0-rc14.
@@ -578,6 +587,27 @@ await vx.poll()
 
 ---
 
+## 📞 Voice Calls (experimental)
+
+Audio-call support (ported from ourin-baileys) via a WASM call stack + WebRTC relay. It is **opt-in**: nothing starts until you create a `VoipClient`. Requires the optional `@roamhq/wrtc` peer dependency.
+
+```js
+import { VoipClient } from '@vanzxysenpai/baileys'
+
+const voip = new VoipClient({ resourcesPath: './voip-resources' })
+await voip.connectWithSocket(sock)
+
+const call = await voip.call('628123456789')
+
+call.on('ringing', () => console.log('Ringing...'))
+call.on('connected', () => console.log('Call connected'))
+call.on('ended', (reason) => console.log('Call ended:', reason))
+```
+
+`ActiveCall` and `CallState` are exported too. Use calls responsibly: unsolicited or bulk calling is the fastest way to get a number restricted by WhatsApp.
+
+---
+
 ## 🔎 User Sync Queries
 
 `WAUSync` (`USyncQuery` / `USyncUser` + protocols) lets you check things like WhatsApp registration, device lists, status, and username info for a JID before you message it — the same mechanism behind `sock.onWhatsApp()`.

package/lib/VoIP/audio-feeder.d.ts

@@ -0,0 +1,15 @@
+export class AudioFeeder {
+    constructor(sampleRate: any, channels: any, framesPerChunk: any, onChunk: any, source?: string);
+    sampleRate: any;
+    channels: any;
+    framesPerChunk: any;
+    onChunk: any;
+    source: string;
+    droppedChunks: number;
+    underflowChunks: number;
+    bytesProduced: number;
+    chunksEmitted: number;
+    start: () => void;
+    stop: () => void;
+    #private;
+}

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.d.ts

@@ -0,0 +1,22 @@
+export { CallState } from "./types.js";
+export class ActiveCall {
+    constructor(callId: any, engine: any, durationMs: any);
+    _audioSource: string;
+    callId: any;
+    engine: any;
+    get state(): number;
+    end: () => void;
+    mute: (muted: any) => void;
+    waitForEnd: () => Promise<any>;
+    _updateState: (state: any) => void;
+    _emitAudio: (pcm: any) => void;
+    _forceEnd: (reason: any) => void;
+    #private;
+}
+export class VoipClient {
+    constructor(config?: {});
+    connectWithSocket: (existingSock: any) => Promise<void>;
+    call: (phoneNumber: any, opts?: {}) => Promise<ActiveCall>;
+    disconnect: () => void;
+    #private;
+}

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,16 @@
+export class RelayRtcTransport {
+    constructor(config: any);
+    config: any;
+    updateRelayList: (update: any) => void;
+    send: (packet: any, ip: any, port: any) => any;
+    getStats: () => {
+        openConnections: number;
+        sentPackets: number;
+        receivedPackets: number;
+        sentBytes: number;
+        receivedBytes: number;
+        droppedPackets: number;
+    };
+    closeAll: () => Promise<void>;
+    #private;
+}