@japofc/baileys 2.1.0

package/lib/VoIP/call-recorder.js

@@ -0,0 +1,73 @@
+/**
+ * JAP@Add --- minimal WAV recorder for VoIP inbound audio.
+ *
+ * Collects the Float32 PCM chunks emitted as ActiveCall 'audio' events and
+ * writes a standard 16-bit PCM .wav file. Zero dependencies.
+ *
+ * NOTE: the WASM engine does not report the playback sample rate; 16000 Hz
+ * mono matches the capture path it was tested against. If recordings sound
+ * pitched up/down, pass the correct `sampleRate` explicitly.
+ */
+import { openSync, writeSync, closeSync } from 'node:fs';
+const clampToInt16 = (sample) => {
+    const s = Math.max(-1, Math.min(1, sample));
+    return s < 0 ? Math.round(s * 0x8000) : Math.round(s * 0x7fff);
+};
+export const createWavRecorder = (filePath, { sampleRate = 16000, channels = 1 } = {}) => {
+    if (!filePath || typeof filePath !== 'string') {
+        throw new TypeError('createWavRecorder(filePath) requires a file path string');
+    }
+    const fd = openSync(filePath, 'w');
+    const header = Buffer.alloc(44);
+    header.write('RIFF', 0);
+    header.write('WAVE', 8);
+    header.write('fmt ', 12);
+    header.writeUInt32LE(16, 16); // PCM fmt chunk size
+    header.writeUInt16LE(1, 20); // audio format = PCM
+    header.writeUInt16LE(channels, 22);
+    header.writeUInt32LE(sampleRate, 24);
+    header.writeUInt32LE(sampleRate * channels * 2, 28); // byte rate
+    header.writeUInt16LE(channels * 2, 32); // block align
+    header.writeUInt16LE(16, 34); // bits per sample
+    header.write('data', 36);
+    writeSync(fd, header);
+    let dataBytes = 0;
+    let closed = false;
+    return {
+        /** Append one Float32Array PCM chunk (interleaved if multi-channel). */
+        write(pcm) {
+            if (closed) {
+                throw new Error('WAV recorder is already closed');
+            }
+            if (!pcm?.length) {
+                return;
+            }
+            const out = Buffer.allocUnsafe(pcm.length * 2);
+            for (let i = 0; i < pcm.length; i++) {
+                out.writeInt16LE(clampToInt16(pcm[i]), i * 2);
+            }
+            writeSync(fd, out);
+            dataBytes += out.length;
+        },
+        /** Finalize sizes in the header and close the file. Safe to call twice. */
+        close() {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            try {
+                const sizes = Buffer.alloc(8);
+                sizes.writeUInt32LE(36 + dataBytes, 0); // RIFF chunk size
+                sizes.writeUInt32LE(dataBytes, 4); // data chunk size
+                writeSync(fd, sizes, 0, 4, 4);
+                writeSync(fd, sizes, 4, 4, 40);
+            }
+            finally {
+                closeSync(fd);
+            }
+        },
+        get bytesWritten() {
+            return dataBytes;
+        }
+    };
+};

package/lib/VoIP/index.d.ts

@@ -0,0 +1,86 @@
+import { EventEmitter } from 'events';
+export { CallState } from './types.js';
+export { createWavRecorder } from './call-recorder.js';
+export type { WavRecorder, WavRecorderOptions } from './call-recorder.js';
+
+export interface VoipClientConfig {
+    /** Pre-built WASM engine (tests + custom stacks). */
+    engine?: any;
+    /** Pre-built relay transport. */
+    relay?: any;
+    /** Path to the VOIP wasm resources directory. */
+    resourcesPath?: string;
+    [key: string]: any;
+}
+
+export interface AnswerCallOptions {
+    audioSource?: string;
+    durationMs?: number;
+    isMicEnabled?: boolean;
+}
+
+export interface JoinGroupCallOptions {
+    audioSource?: string;
+    durationMs?: number;
+    hasVideo?: boolean;
+    joinAndAccept?: boolean;
+    chatName?: string;
+}
+
+export interface StartGroupCallOptions {
+    audioSource?: string;
+    durationMs?: number;
+    useVideo?: boolean;
+    chatName?: string;
+}
+
+export interface RecoverCallOptions {
+    peerJid?: string;
+    callId?: string;
+    retryCount?: number;
+}
+
+/** A live (or recently ended) voice/video call. Emits 'audio' with PCM chunks. */
+export class ActiveCall extends EventEmitter {
+    constructor(callId: string, engine: any, durationMs: number, meta?: Record<string, any>);
+    readonly state: any;
+    startedAt: number;
+    end(): any;
+    mute(muted: boolean): any;
+    invite(pnUserJid: string, lidUserJid?: string, deviceJids?: string[]): any;
+    removeParticipant(peerJid: string): any;
+    requestMute(peerJid: string): any;
+    react(reaction: string): any;
+    setHandRaised(raised: boolean): any;
+    getDurationMs(): number;
+    recordToFile(filePath: string, opts?: Record<string, any>): any;
+    waitForEnd(): Promise<any>;
+}
+
+/**
+ * Audio-only WhatsApp voice-call client (WASM call stack + WebRTC relay).
+ * Emits 'incoming-call' / 'outgoing-call' / 'call-ended'.
+ */
+export class VoipClient extends EventEmitter {
+    constructor(config?: VoipClientConfig);
+    connectWithSocket(existingSock: any): Promise<void>;
+    isBusy(): boolean;
+    getActiveCall(): ActiveCall | null;
+    getPendingCalls(): any[];
+    rejectCall(callId: string, callFrom: string, options?: { text?: string }): Promise<any>;
+    answerCall(callId: string, options?: AnswerCallOptions): Promise<any>;
+    joinGroupCall(callId: string, options?: JoinGroupCallOptions): Promise<any>;
+    startGroupCall(groupJid: string, participants?: string[], options?: StartGroupCallOptions): Promise<any>;
+    rejoinGroupCall(overrides?: Record<string, any>): Promise<any>;
+    inviteToGroupCall(phoneNumber: string, deviceJids?: string[]): Promise<any>;
+    removeGroupParticipant(peerJid: string): Promise<any>;
+    previewCallLink(token: string, opts?: Record<string, any>): any;
+    joinCallLink(): any;
+    getStats(): any;
+    recoverCall(options?: RecoverCallOptions): Promise<any>;
+    call(phoneNumber: string, opts?: Record<string, any>): Promise<any>;
+    disconnect(): any;
+}
+
+/** Instantiate VoipClient on an active socket (also sets `sock.voip`). */
+export declare const attachVoip: (sock: any, config?: VoipClientConfig) => Promise<VoipClient>;