@zelynskybail/baileys 2.6.31 → 2.6.34

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/BUILD_STATUS.md CHANGED
@@ -1,21 +1,17 @@
1
- # ZelynskyBail Baileys 2.6.28 — build and validation status
1
+ # Build Status — 2.6.34
2
2
 
3
- This is the requested versioned source build. It is not a claim of complete WhatsApp protocol parity or production certification.
3
+ ## Added
4
+ - Experimental shared-socket VoIP engine ported from `@japofc/baileys` 2.4.7-new.
5
+ - Group-call join/start APIs, incoming offer handling, audio feeder, relay transport, WASM worker engine, call recovery and recorder.
6
+ - Existing Zelynsky VoIP adapter retained under its original `VoipClient` export.
4
7
 
5
- ## Implemented in this package
6
- - Baileys v7-derived socket/auth/Signal/WABinary/WAProto/WAM/WAUSync core from the supplied Delkira distribution.
7
- - Interactive and rich-message builders, including bundled MessageBuilder 4.7, Button V1/V2, Carousel, AIRich/ORich, NativeFlow, polls, albums, contacts, locations, link preview and status helpers.
8
- - ButtonV3 hydrated-template builder and experimental A2UI payload validator.
9
- - In-memory message indexing/search, anti-delete event observer, and atomic JSON PersistentStore.
10
- - Newsletter, groups, communities, business, privacy, profile, message edit/delete and status protocol methods present in the supplied core.
11
- - Call event/reject/link/privacy helpers. Optional outbound 1:1 voice call client is exposed through `VoipClient` using its own linked-device session.
12
- - Group Status helper for text, image, video, audio and sticker, backed by the core `swgc` path.
13
- - VCardBuilder alias over the built-in contact-card builder.
14
- - No automatic newsletter/channel follow or invite acceptance on connect.
8
+ ## Runtime requirements
9
+ - Node.js >=20.
10
+ - `@roamhq/wrtc` optional native dependency for WebRTC relay transport.
11
+ - WhatsApp Web WASM resources fetched with `npm run voip:fetch-wasm`.
12
+ - `ffmpeg` available on PATH for file-based audio sources.
15
13
 
16
- ## Explicit limitations
17
- - VoIP engine supports outbound 1:1 voice calls and audio streaming only. It does not support incoming RTC calls, video calls, or group calls. It uses its own linked-device `authDir`, not the parent socket.
18
- - A2UI is an experimental payload builder/validator; live rendering depends on WhatsApp client support and has not been verified.
19
- - Group Status, every Casileys-specific manager, and every undocumented private WhatsApp payload are not claimed complete.
20
- - Runtime install, live pairing, media relay, and end-to-end tests have not been performed in this environment.
21
- - Before public npm publication, review every upstream license and preserve notices. The bundled MessageBuilder license restricts redistribution as a standalone product; it is bundled as a module with the original watermark retained, but permission should be confirmed for public distribution.
14
+ ## Status
15
+ - API port and package wiring added.
16
+ - Syntax and package-integrity checks are required before release.
17
+ - Group-call interoperability has not been tested against a live WhatsApp account in this build environment. Treat group calling as experimental.
package/CHANGELOG.md CHANGED
@@ -1,3 +1,14 @@
1
+ # Changelog
2
+
3
+ ## 2.6.34
4
+
5
+ - Added experimental JAPofc 2.4.7-new based shared-socket VoIP engine.
6
+ - Added incoming call offer handling, inbound group-call join, outbound group-call initiation, participant controls, audio feeder, relay transport, WASM engine, call recovery and WAV recording.
7
+ - Preserved the existing Zelynsky `CallManager` and separate-session `VoipClient` API.
8
+ - Added `attachVoip`, `GroupVoipClient`, `ActiveCall`, and `CallState` exports.
9
+ - Added WASM resource fetch script and optional `@roamhq/wrtc` dependency.
10
+ - Updated README and attribution notices.
11
+
1
12
  ## 2.6.31
2
13
 
3
14
  - VoIP: persistent authDir (no re-QR after first pair)
@@ -0,0 +1,21 @@
1
+ MIT License
2
+
3
+ Copyright (c) J.AP (JAPofc)
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
package/README.md CHANGED
@@ -123,28 +123,66 @@ await store.close()
123
123
 
124
124
  Tulisnya atomik, tapi ini untuk metadata kecil. Jangan dipakai sebagai database.
125
125
 
126
- ## Panggilan suara
126
+ ## Panggilan suara dan Group Call (experimental)
127
+
128
+ Adapter VoIP lama tetap tersedia dan tidak berubah:
127
129
 
128
130
  ```js
129
131
  import { VoipClient } from '@zelynskybail/baileys'
130
132
 
131
133
  const voip = new VoipClient({ authDir: './voip-session' })
132
134
  await voip.connect()
133
-
134
135
  const call = await voip.call('628123456789', {
135
136
  audioSource: './audio.mp3',
136
137
  durationMs: 30000
137
138
  })
139
+ ```
140
+
141
+ Untuk engine VoIP berbasis socket utama (port JAPofc 2.4.7-new):
138
142
 
139
- call.on('connected', () => console.log('Tersambung'))
140
- call.on('ended', reason => console.log('Selesai:', reason))
143
+ ```js
144
+ import { attachVoip } from '@zelynskybail/baileys/calls'
145
+
146
+ const voip = await attachVoip(sock, {
147
+ autoReject: false,
148
+ autoJoinGroup: false,
149
+ offerTtlMs: 45000
150
+ })
151
+
152
+ voip.on('incoming-call', info => {
153
+ console.log('Panggilan masuk:', info)
154
+ })
155
+
156
+ const pending = voip.getPendingCalls()
157
+ // Panggilan grup masuk yang masih pending:
158
+ const groupOffer = pending.find(call => call.isGroupCall)
159
+ if (groupOffer) {
160
+ const call = await voip.joinGroupCall(groupOffer.callId, {
161
+ audioSource: './playlist.mp3',
162
+ durationMs: 10 * 60 * 1000,
163
+ chatName: 'KuzeMD Music'
164
+ })
165
+ call.on('connected', () => console.log('Bot masuk group call'))
166
+ call.on('ended', reason => console.log('Group call selesai:', reason))
167
+ }
141
168
  ```
142
169
 
143
- Yang bisa: panggilan suara keluar 1:1, audio MP3/WAV dan PCM.
144
- Yang belum: media RTC masuk, video call, panggilan grup.
145
- `ffmpeg` hanya perlu kalau sumber audionya file.
170
+ API group-call:
171
+ - `attachVoip(sock, config)` / `new CallManager(sock).attachVoip(config)`
172
+ - `getPendingCalls()`, `rejectCall(callId, from)`, `answerCall(callId, options)`
173
+ - `joinGroupCall(callId, options)`, `startGroupCall(groupJid, participants, options)`
174
+ - `rejoinGroupCall(overrides)`, `inviteToGroupCall(number)`, `removeGroupParticipant(jid)`
175
+ - `setAudioSource(source)`, `getActiveCall()`, `isBusy()`, `getStats()`, `recoverCall(options)`
176
+ - `call.setAudioSource(source)`, `call.end()`, `call.mute(boolean)`, `call.waitForEnd()`
177
+
178
+ Engine group-call ini masih **experimental** dan butuh resource WhatsApp Web WASM serta native WebRTC. Pasang `@roamhq/wrtc` yang cocok dengan platform Node.js lu, lalu ambil resource WASM:
179
+
180
+ ```sh
181
+ npm i @roamhq/wrtc
182
+ npm run voip:fetch-wasm
183
+ ```
146
184
 
147
- Adapter ini memakai sesi linked-device terpisah dan tidak menyentuh socket utama.
185
+ `ffmpeg` diperlukan untuk memutar sumber audio berbentuk file. `attachVoip()` menggunakan socket Baileys yang sudah login; ia tidak membuat sesi linked-device kedua. Uji di akun/grup percobaan terlebih dahulu. API yang tersedia tidak menjamin WhatsApp akan menerima setiap panggilan atau bahwa koneksi RTC stabil di semua platform.
148
186
 
149
187
  ## Profil performa
150
188
 
@@ -6,3 +6,10 @@
6
6
  - **baileys-caller** — optional outbound audio calling adapter, authored by ShellTear and distributed under MIT by the npm fork used by this project. It is loaded dynamically and its license applies to that dependency.
7
7
 
8
8
  No third-party code is represented as wholly original ZelynskyBail work.
9
+
10
+
11
+ ## JAPofc VoIP implementation
12
+
13
+ The experimental shared-socket VoIP engine under `lib/VoIP/group-call.js` and its supporting modules (`audio-feeder.js`, `call-recorder.js`, `relay-transport.js`, `signaling.js`, `types.js`, `wasm-engine.js`, and `worker-bootstrap.js`) are ported from `@japofc/baileys` version `2.4.7-new`, authored by J.AP (JAPofc).
14
+
15
+ The source project declares the MIT License. The port retains the original JAPofc source attribution/comments. This notice is provided in addition to the upstream Baileys and other third-party notices already included with this package.
@@ -0,0 +1,20 @@
1
+ import { existsSync } from 'node:fs';
2
+
3
+ export async function resolveFfmpegPath() {
4
+ const override = process.env.FFMPEG_PATH;
5
+ if (override && existsSync(override)) return override;
6
+
7
+ try {
8
+ const mod = await import('ffmpeg-static');
9
+ const candidate = mod.default || mod.path || mod;
10
+ if (typeof candidate === 'string' && candidate && existsSync(candidate)) return candidate;
11
+ } catch {}
12
+
13
+ try {
14
+ const mod = await import('@ffmpeg-installer/ffmpeg');
15
+ const candidate = mod.path || mod.default?.path;
16
+ if (typeof candidate === 'string' && candidate && existsSync(candidate)) return candidate;
17
+ } catch {}
18
+
19
+ return 'ffmpeg';
20
+ }
@@ -0,0 +1,20 @@
1
+ export declare class AudioFeeder {
2
+ #private;
3
+ private readonly sampleRate;
4
+ private readonly channels;
5
+ private readonly framesPerChunk;
6
+ private readonly onChunk;
7
+ private readonly source;
8
+ droppedChunks: number;
9
+ underflowChunks: number;
10
+ bytesProduced: number;
11
+ chunksEmitted: number;
12
+ constructor(sampleRate: number, channels: number, framesPerChunk: number, onChunk: (chunk: Float32Array) => void, source?: string | {
13
+ data: Buffer;
14
+ ext?: string;
15
+ });
16
+ start: () => void;
17
+ /** Swap the decode source mid-stream; returns true when the running pipeline was restarted with the new source. */
18
+ swapSource: (source: string | { data: Buffer; ext?: string }) => boolean;
19
+ stop: () => void;
20
+ }
@@ -0,0 +1,208 @@
1
+ /**
2
+ * lib/VoIP/audio-feeder.js
3
+ * Author: J.AP (@japofc/baileys)
4
+ *
5
+ * Decodes an audio `source` to f32le PCM with ffmpeg and meters fixed-size
6
+ * frames to the WASM uplink at real-time cadence. Supports file paths, `lavfi:`
7
+ * generators, in-memory `{ data: Buffer, ext }`, and a silent default. A small
8
+ * warm-up buffer smooths startup; back-pressure pauses ffmpeg when the queue
9
+ * fills; underflows emit silence so the uplink never stalls.
10
+ */
11
+ import { spawn } from 'node:child_process';
12
+ import { randomBytes } from 'node:crypto';
13
+ import { unlinkSync, writeFileSync } from 'node:fs';
14
+ import { tmpdir } from 'node:os';
15
+ import { join } from 'node:path';
16
+
17
+ const LOW_WATERMARK_CHUNKS = 16;
18
+ const MAX_QUEUED_CHUNKS = 1024;
19
+ const WARMUP_MS = 500;
20
+
21
+ export class AudioFeeder {
22
+ // public counters / config
23
+ sampleRate;
24
+ channels;
25
+ framesPerChunk;
26
+ onChunk;
27
+ source;
28
+ droppedChunks = 0;
29
+ underflowChunks = 0;
30
+ bytesProduced = 0;
31
+ chunksEmitted = 0;
32
+
33
+ // internal state
34
+ #proc = null;
35
+ #pending = Buffer.alloc(0);
36
+ #tempFile = null;
37
+ #queue = [];
38
+ #emitTimer = null;
39
+ #nextEmitAtMs = 0;
40
+ #warmupUntilMs = 0;
41
+ #starting = false; // async binary resolution in flight
42
+ #started = false; // start() called, not yet stop()ed (survives decoder death)
43
+ #generation = 0; // bumped on stop() to cancel a pending spawn
44
+
45
+ constructor(sampleRate, channels, framesPerChunk, onChunk, source = 'silence') {
46
+ this.sampleRate = sampleRate;
47
+ this.channels = channels;
48
+ this.framesPerChunk = framesPerChunk;
49
+ this.onChunk = onChunk;
50
+ this.source = source;
51
+ }
52
+
53
+ start = () => {
54
+ if (this.#proc || this.#starting) return;
55
+ this.#started = true;
56
+ this.#starting = true;
57
+ const generation = ++this.#generation;
58
+ // resolve the ffmpeg binary (ffmpeg-static / installer / PATH / env), then spawn
59
+ void import('../Utils/ffmpeg-path.js')
60
+ .then(({ resolveFfmpegPath }) => resolveFfmpegPath())
61
+ .then((bin) => {
62
+ this.#starting = false;
63
+ if (generation === this.#generation) this.#spawnDecoder(bin ?? 'ffmpeg');
64
+ })
65
+ .catch(() => {
66
+ this.#starting = false;
67
+ if (generation === this.#generation) this.#spawnDecoder('ffmpeg');
68
+ });
69
+ };
70
+
71
+ /**
72
+ * Swap the audio source mid-stream (greeting → menu → hold music). When
73
+ * running, restarts the decoder with the new source and returns true; when
74
+ * not started, just stores it for the next start() and returns false.
75
+ */
76
+ swapSource = (source) => {
77
+ const wasRunning = this.#started;
78
+ this.source = source;
79
+ if (!wasRunning) return false;
80
+ this.stop();
81
+ this.start();
82
+ return true;
83
+ };
84
+
85
+ stop = () => {
86
+ this.#started = false;
87
+ this.#generation += 1; // cancel a spawn still resolving its binary
88
+ this.#starting = false;
89
+ if (this.#emitTimer) {
90
+ clearTimeout(this.#emitTimer);
91
+ this.#emitTimer = null;
92
+ }
93
+ this.#proc?.kill('SIGTERM');
94
+ this.#proc = null;
95
+ this.#pending = Buffer.alloc(0);
96
+ this.#queue = [];
97
+ this.#warmupUntilMs = 0;
98
+ this.#cleanupTempFile();
99
+ };
100
+
101
+ #cleanupTempFile = () => {
102
+ if (!this.#tempFile) return;
103
+ try { unlinkSync(this.#tempFile); } catch { /* best effort */ }
104
+ this.#tempFile = null;
105
+ };
106
+
107
+ /** Build the ffmpeg input args for the current source. */
108
+ #inputArgs = () => {
109
+ if (!this.source || this.source === 'silence') {
110
+ return ['-f', 'lavfi', '-i', `aevalsrc=0:d=3600:s=${this.sampleRate}`];
111
+ }
112
+ if (this.source && typeof this.source === 'object' && Buffer.isBuffer(this.source.data)) {
113
+ const ext = String(this.source.ext || 'ogg').replace(/[^a-z0-9]/gi, '') || 'ogg';
114
+ const tmp = join(tmpdir(), `jap-voip-${Date.now()}-${randomBytes(4).toString('hex')}.${ext}`);
115
+ writeFileSync(tmp, this.source.data);
116
+ this.#tempFile = tmp;
117
+ return ['-i', tmp];
118
+ }
119
+ if (typeof this.source === 'string' && this.source.startsWith('lavfi:')) {
120
+ return ['-f', 'lavfi', '-i', this.source.slice('lavfi:'.length)];
121
+ }
122
+ return ['-i', this.source];
123
+ };
124
+
125
+ #spawnDecoder = (ffmpegBin) => {
126
+ if (this.#proc) return;
127
+ const chunkSamples = this.framesPerChunk * this.channels;
128
+ const chunkBytes = chunkSamples * Float32Array.BYTES_PER_ELEMENT;
129
+ const chunkIntervalMs = (this.framesPerChunk / this.sampleRate) * 1000;
130
+
131
+ this.#proc = spawn(ffmpegBin, [
132
+ '-hide_banner',
133
+ '-loglevel', 'error',
134
+ '-thread_queue_size', '512',
135
+ ...this.#inputArgs(),
136
+ '-f', 'f32le',
137
+ '-ac', String(this.channels),
138
+ '-ar', String(this.sampleRate),
139
+ 'pipe:1'
140
+ ]);
141
+
142
+ this.#proc.stdout.on('data', (chunk) => this.#ingest(chunk, chunkBytes, chunkSamples));
143
+ this.#proc.on('error', (err) => {
144
+ if (err?.code === 'ENOENT') {
145
+ process.stderr.write('[AudioFeeder] ffmpeg binary not found — install ffmpeg to feed call audio (or use audioSource: "silence").\n');
146
+ }
147
+ this.#proc = null;
148
+ });
149
+ this.#proc.stderr.on('data', (chunk) => process.stderr.write(`[AudioFeeder] ${chunk.toString().trim()}\n`));
150
+ this.#proc.on('exit', (code) => {
151
+ if (code !== 0 && code !== null) process.stderr.write(`[AudioFeeder] ffmpeg exited with code=${code}\n`);
152
+ this.#proc = null;
153
+ });
154
+
155
+ this.#nextEmitAtMs = 0;
156
+ this.#warmupUntilMs = Date.now() + WARMUP_MS;
157
+ this.#scheduleNext(chunkSamples, chunkIntervalMs);
158
+ };
159
+
160
+ /** Slice raw ffmpeg output into fixed frames, applying back-pressure. */
161
+ #ingest = (chunk, chunkBytes, chunkSamples) => {
162
+ this.#pending = Buffer.concat([this.#pending, chunk]);
163
+ while (this.#pending.length >= chunkBytes) {
164
+ if (this.#queue.length >= MAX_QUEUED_CHUNKS) {
165
+ this.#proc?.stdout.pause();
166
+ break;
167
+ }
168
+ const frame = this.#pending.subarray(0, chunkBytes);
169
+ this.#pending = this.#pending.subarray(chunkBytes);
170
+ const out = new Float32Array(chunkSamples);
171
+ out.set(new Float32Array(frame.buffer, frame.byteOffset, chunkSamples));
172
+ this.bytesProduced += chunkBytes;
173
+ this.#queue.push(out);
174
+ }
175
+ };
176
+
177
+ #scheduleNext = (chunkSamples, chunkIntervalMs) => {
178
+ if (!this.#proc) return;
179
+ const now = Date.now();
180
+ if (this.#nextEmitAtMs === 0) this.#nextEmitAtMs = now;
181
+ const delayMs = Math.max(0, this.#nextEmitAtMs - now);
182
+ this.#emitTimer = setTimeout(() => {
183
+ this.#emitTimer = null;
184
+ // during warm-up, wait for the queue to fill before metering out
185
+ if (this.#queue.length < LOW_WATERMARK_CHUNKS && Date.now() < this.#warmupUntilMs) {
186
+ this.#nextEmitAtMs = Date.now() + 10;
187
+ this.#scheduleNext(chunkSamples, chunkIntervalMs);
188
+ return;
189
+ }
190
+ this.#flushOne(chunkSamples);
191
+ this.#nextEmitAtMs += chunkIntervalMs;
192
+ this.#scheduleNext(chunkSamples, chunkIntervalMs);
193
+ }, delayMs);
194
+ };
195
+
196
+ #flushOne = (chunkSamples) => {
197
+ let next = this.#queue.shift();
198
+ if (!next) {
199
+ next = new Float32Array(chunkSamples); // underflow → silence
200
+ this.underflowChunks += 1;
201
+ }
202
+ this.chunksEmitted += 1;
203
+ this.onChunk(next);
204
+ if (this.#proc?.stdout.isPaused() && this.#queue.length <= MAX_QUEUED_CHUNKS / 4) {
205
+ this.#proc.stdout.resume();
206
+ }
207
+ };
208
+ }
@@ -0,0 +1,13 @@
1
+ /**
2
+ * JAP@Add --- Type declarations for the VoIP WAV recorder.
3
+ */
4
+ export interface WavRecorderOptions {
5
+ sampleRate?: number;
6
+ channels?: number;
7
+ }
8
+ export interface WavRecorder {
9
+ write(pcm: Float32Array): void;
10
+ close(): void;
11
+ readonly bytesWritten: number;
12
+ }
13
+ export declare const createWavRecorder: (filePath: string, opts?: WavRecorderOptions) => WavRecorder;
@@ -0,0 +1,77 @@
1
+ /**
2
+ * lib/VoIP/call-recorder.js
3
+ * Author: J.AP (@japofc/baileys)
4
+ *
5
+ * Minimal, dependency-free WAV recorder. Collects the Float32 PCM chunks
6
+ * emitted by an ActiveCall 'audio' event and writes a canonical 16-bit PCM
7
+ * .wav. The WASM engine doesn't report the playback rate, so 16 kHz mono is the
8
+ * default (the rate the capture path was validated at); pass `sampleRate`
9
+ * explicitly if recordings sound pitched.
10
+ */
11
+ import { openSync, writeSync, closeSync } from 'node:fs';
12
+
13
+ /** Convert a float sample in [-1, 1] to a signed 16-bit integer. */
14
+ const toInt16 = (sample) => {
15
+ const s = Math.max(-1, Math.min(1, sample));
16
+ return Math.round(s * (s < 0 ? 0x8000 : 0x7fff));
17
+ };
18
+
19
+ /** Build the 44-byte canonical WAV header (sizes patched on close). */
20
+ const buildHeader = (sampleRate, channels) => {
21
+ const h = Buffer.alloc(44);
22
+ h.write('RIFF', 0);
23
+ h.write('WAVE', 8);
24
+ h.write('fmt ', 12);
25
+ h.writeUInt32LE(16, 16); // fmt chunk size
26
+ h.writeUInt16LE(1, 20); // PCM
27
+ h.writeUInt16LE(channels, 22);
28
+ h.writeUInt32LE(sampleRate, 24);
29
+ h.writeUInt32LE(sampleRate * channels * 2, 28); // byte rate
30
+ h.writeUInt16LE(channels * 2, 32); // block align
31
+ h.writeUInt16LE(16, 34); // bits per sample
32
+ h.write('data', 36);
33
+ return h;
34
+ };
35
+
36
+ export const createWavRecorder = (filePath, { sampleRate = 16000, channels = 1 } = {}) => {
37
+ if (!filePath || typeof filePath !== 'string') {
38
+ throw new TypeError('createWavRecorder(filePath) requires a file path string');
39
+ }
40
+
41
+ const fd = openSync(filePath, 'w');
42
+ writeSync(fd, buildHeader(sampleRate, channels));
43
+
44
+ let dataBytes = 0;
45
+ let closed = false;
46
+
47
+ return {
48
+ /** Append one Float32Array PCM chunk (interleaved when multi-channel). */
49
+ write(pcm) {
50
+ if (closed) throw new Error('WAV recorder is already closed');
51
+ if (!pcm?.length) return;
52
+ const out = Buffer.allocUnsafe(pcm.length * 2);
53
+ for (let i = 0; i < pcm.length; i++) out.writeInt16LE(toInt16(pcm[i]), i * 2);
54
+ writeSync(fd, out);
55
+ dataBytes += out.length;
56
+ },
57
+
58
+ /** Patch the RIFF/data sizes and close. Idempotent. */
59
+ close() {
60
+ if (closed) return;
61
+ closed = true;
62
+ try {
63
+ const sizes = Buffer.alloc(8);
64
+ sizes.writeUInt32LE(36 + dataBytes, 0); // RIFF chunk size
65
+ sizes.writeUInt32LE(dataBytes, 4); // data chunk size
66
+ writeSync(fd, sizes, 0, 4, 4); // patch RIFF size @ offset 4
67
+ writeSync(fd, sizes, 4, 4, 40); // patch data size @ offset 40
68
+ } finally {
69
+ closeSync(fd);
70
+ }
71
+ },
72
+
73
+ get bytesWritten() {
74
+ return dataBytes;
75
+ }
76
+ };
77
+ };
@@ -0,0 +1,105 @@
1
+ import { EventEmitter } from 'events';
2
+ export { CallState } from './types.js';
3
+ export { createWavRecorder } from './call-recorder.js';
4
+ export type { WavRecorder, WavRecorderOptions } from './call-recorder.js';
5
+
6
+ export interface VoipClientConfig {
7
+ /** Pre-built WASM engine (tests + custom stacks). */
8
+ engine?: any;
9
+ /** Pre-built relay transport. */
10
+ relay?: any;
11
+ /** Path to the VOIP wasm resources directory. */
12
+ resourcesPath?: string;
13
+ /** Relay-health watchdog poll interval in ms (default 5000; 0 disables). */
14
+ watchdogIntervalMs?: number;
15
+ /** Consecutive empty-relay polls before recovery kicks in (default 3). */
16
+ watchdogMaxSilent?: number;
17
+ /**
18
+ * Recovery budget per call (default 3): after this many consecutive failed
19
+ * recoveries the client emits 'call-unrecoverable' and force-ends the call
20
+ * instead of retrying forever.
21
+ */
22
+ watchdogMaxRecoveries?: number;
23
+ [key: string]: any;
24
+ }
25
+
26
+ export interface AnswerCallOptions {
27
+ audioSource?: string;
28
+ durationMs?: number;
29
+ isMicEnabled?: boolean;
30
+ }
31
+
32
+ export interface JoinGroupCallOptions {
33
+ audioSource?: string;
34
+ durationMs?: number;
35
+ hasVideo?: boolean;
36
+ joinAndAccept?: boolean;
37
+ chatName?: string;
38
+ }
39
+
40
+ export interface StartGroupCallOptions {
41
+ audioSource?: string;
42
+ durationMs?: number;
43
+ useVideo?: boolean;
44
+ chatName?: string;
45
+ }
46
+
47
+ export interface RecoverCallOptions {
48
+ peerJid?: string;
49
+ callId?: string;
50
+ retryCount?: number;
51
+ }
52
+
53
+ /** A live (or recently ended) voice/video call. Emits 'audio' with PCM chunks. */
54
+ export class ActiveCall extends EventEmitter {
55
+ constructor(callId: string, engine: any, durationMs: number, meta?: Record<string, any>);
56
+ readonly state: any;
57
+ startedAt: number;
58
+ end(): any;
59
+ mute(muted: boolean): any;
60
+ invite(pnUserJid: string, lidUserJid?: string, deviceJids?: string[]): any;
61
+ removeParticipant(peerJid: string): any;
62
+ requestMute(peerJid: string): any;
63
+ react(reaction: string): any;
64
+ setHandRaised(raised: boolean): any;
65
+ getDurationMs(): number;
66
+ recordToFile(filePath: string, opts?: Record<string, any>): any;
67
+ /**
68
+ * Swap what the call is playing WITHOUT hanging up: a file path/URL,
69
+ * `{ data: Buffer, ext }`, a `lavfi:` graph, or `"silence"`. Returns true
70
+ * when a live decoder was swapped, false when audio capture has not
71
+ * started yet (the source is remembered for when it does).
72
+ */
73
+ setAudioSource(source: string | { data: Buffer; ext?: string }): boolean;
74
+ waitForEnd(): Promise<any>;
75
+ }
76
+
77
+ /**
78
+ * Audio-only WhatsApp voice-call client (WASM call stack + WebRTC relay).
79
+ * Emits 'incoming-call' / 'outgoing-call' / 'call-ended'.
80
+ */
81
+ export class VoipClient extends EventEmitter {
82
+ constructor(config?: VoipClientConfig);
83
+ connectWithSocket(existingSock: any): Promise<void>;
84
+ isBusy(): boolean;
85
+ getActiveCall(): ActiveCall | null;
86
+ /** Swap the active call's uplink audio source mid-call. Throws when no call is active. */
87
+ setAudioSource(source: string | { data: Buffer; ext?: string }): boolean;
88
+ getPendingCalls(): any[];
89
+ rejectCall(callId: string, callFrom: string, options?: { text?: string }): Promise<any>;
90
+ answerCall(callId: string, options?: AnswerCallOptions): Promise<any>;
91
+ joinGroupCall(callId: string, options?: JoinGroupCallOptions): Promise<any>;
92
+ startGroupCall(groupJid: string, participants?: string[], options?: StartGroupCallOptions): Promise<any>;
93
+ rejoinGroupCall(overrides?: Record<string, any>): Promise<any>;
94
+ inviteToGroupCall(phoneNumber: string, deviceJids?: string[]): Promise<any>;
95
+ removeGroupParticipant(peerJid: string): Promise<any>;
96
+ previewCallLink(token: string, opts?: Record<string, any>): any;
97
+ joinCallLink(): any;
98
+ getStats(): any;
99
+ recoverCall(options?: RecoverCallOptions): Promise<any>;
100
+ call(phoneNumber: string, opts?: Record<string, any>): Promise<any>;
101
+ disconnect(): any;
102
+ }
103
+
104
+ /** Instantiate VoipClient on an active socket (also sets `sock.voip`). */
105
+ export declare const attachVoip: (sock: any, config?: VoipClientConfig) => Promise<VoipClient>;