kage-baileys 3.0.6 → 3.2.3

package/lib/VoIP/audio-feeder.js

@@ -134,3 +134,153 @@ const DEFAULT_WARMUP_MS = 500;
         }
     };
 } exports.AudioFeeder = AudioFeeder;
+
+// Kage: herramientas de Kage.
+const __kageModule103 = (() => {
+const module = { exports: {} }; const exports = module.exports;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioFeeder = void 0;
+/**
+ * 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
+ */
+const node_child_process_1 = require("node:child_process");
+const LOW_WATERMARK_CHUNKS = 16;
+const MAX_QUEUED_CHUNKS = 1024;
+const DEFAULT_WARMUP_MS = 500;
+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 = (0, node_child_process_1.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("error", (err) => {
+            process.stderr.write(`[AudioFeeder] ffmpeg process error: ${err.message}\n`);
+            this.#proc = null;
+        });
+        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();
+        }
+    };
+}
+exports.AudioFeeder = AudioFeeder;
+
+return module.exports;
+})();
+for (const key of Object.keys(__kageModule103)) {
+ if (key !== '__esModule' && !Object.prototype.hasOwnProperty.call(exports,key)) Object.defineProperty(exports,key,{enumerable:true,configurable:true,get:()=>__kageModule103[key]});
+}

package/lib/VoIP/index.js

@@ -280,3 +280,292 @@ const isCallReceiptNode = (node) => {
     }
   };
 } exports.VoipClient = VoipClient;
+
+// Kage: herramientas de Kage.
+const __kageModule104 = (() => {
+const module = { exports: {} }; const exports = module.exports;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoipClient = exports.ActiveCall = exports.CallState = void 0;
+const node_events_1 = require("node:events");
+const node_crypto_1 = require("node:crypto");
+const wasm_engine_js_1 = require("./wasm-engine.js");
+const relay_transport_js_1 = require("./relay-transport.js");
+const signaling_js_1 = require("./signaling.js");
+const audio_feeder_js_1 = require("./audio-feeder.js");
+const types_js_1 = require("./types.js");
+var types_js_2 = require("./types.js");
+Object.defineProperty(exports, "CallState", { enumerable: true, get: function () { return types_js_2.CallState; } });
+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 = (0, node_crypto_1.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 = (0, node_crypto_1.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 = (0, node_crypto_1.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);
+};
+class ActiveCall extends node_events_1.EventEmitter {
+    #state = types_js_1.CallState.Idle;
+    #endResolver;
+    #endPromise;
+    #endTimer = null;
+    #ended = false;
+    #hasBeenActive = 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 === types_js_1.CallState.Calling || state === types_js_1.CallState.PreacceptReceived || state === types_js_1.CallState.Active) {
+            this.#hasBeenActive = true;
+        }
+        if (state === types_js_1.CallState.PreacceptReceived)
+            this.emit("ringing");
+        else if (state === types_js_1.CallState.Active)
+            this.emit("connected");
+        else if (this.#hasBeenActive && (state === types_js_1.CallState.Idle || state === types_js_1.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);
+    };
+}
+exports.ActiveCall = ActiveCall;
+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 signaling_js_1.SignalingBridge({ sock: this.#sock });
+        await this.#signaling.init();
+        this.#relay = new relay_transport_js_1.RelayRtcTransport({
+            onTransportMessage: (data, ip, port) => this.#engine?.handleOnTransportMessage(data, ip, port),
+            onIceRtt: (rttMs, ip, port) => this.#engine?.updateIceRtt(rttMs, ip, port),
+        });
+        this.#engine = new wasm_engine_js_1.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)];
+        const allSessionTargets = [...new Set([...deviceList, peerLid, toBareJid(peerLid), targetPnJid, toBareJid(targetPnJid)])];
+        await this.#signaling.ensureSessionsForPeers(allSessionTargets);
+        await new Promise((r) => setTimeout(r, 500));
+        await this.#signaling.issueTcToken(peerLid);
+        const tcToken = await this.#signaling.ensureTcToken(peerLid, targetPnJid);
+        const callId = ("00" + (0, node_crypto_1.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 audio_feeder_js_1.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;
+        }
+    };
+}
+exports.VoipClient = VoipClient;
+
+return module.exports;
+})();
+for (const key of Object.keys(__kageModule104)) {
+ if (key !== '__esModule' && !Object.prototype.hasOwnProperty.call(exports,key)) Object.defineProperty(exports,key,{enumerable:true,configurable:true,get:()=>__kageModule104[key]});
+}