@blckrose/baileys 1.0.0 → 1.1.1

package/lib/Utils/baileys-event-stream.js

@@ -0,0 +1,54 @@
+import EventEmitter from 'events';
+import { createReadStream } from 'fs';
+import { writeFile } from 'fs/promises';
+import { createInterface } from 'readline';
+import { delay } from './generics.js';
+import { makeMutex } from './make-mutex.js';
+
+/**
+ * Captures events from a baileys event emitter & stores them in a file
+ * @param ev The event emitter to read events from
+ * @param filename File to save to
+ */
+export const captureEventStream = (ev, filename) => {
+    const oldEmit = ev.emit;
+    // write mutex so data is appended in order
+    const writeMutex = makeMutex();
+    // monkey patch eventemitter to capture all events
+    ev.emit = function (...args) {
+        const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n';
+        const result = oldEmit.apply(ev, args);
+        writeMutex.mutex(async () => {
+            await writeFile(filename, content, { flag: 'a' });
+        });
+        return result;
+    };
+};
+
+/**
+ * Read event file and emit events from there
+ * @param filename filename containing event data
+ * @param delayIntervalMs delay between each event emit
+ */
+export const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+    const ev = new EventEmitter();
+    const fireEvents = async () => {
+        const fileStream = createReadStream(filename);
+        const rl = createInterface({
+            input: fileStream,
+            crlfDelay: Infinity
+        });
+        for await (const line of rl) {
+            if (line) {
+                const { event, data } = JSON.parse(line);
+                ev.emit(event, data);
+                delayIntervalMs && await delay(delayIntervalMs);
+            }
+        }
+        fileStream.close();
+    };
+    return {
+        ev,
+        task: fireEvents()
+    };
+};

package/lib/Utils/browser-utils.js

@@ -1,28 +1,41 @@
-import { platform, release } from 'os';
+import { platform } from 'os';
 import { proto } from '../../WAProto/index.js';
-const PLATFORM_MAP = {
-    aix: 'AIX',
-    darwin: 'Mac OS',
-    win32: 'Windows',
-    android: 'Android',
-    freebsd: 'FreeBSD',
-    openbsd: 'OpenBSD',
-    sunos: 'Solaris',
-    linux: undefined,
-    haiku: undefined,
-    cygwin: undefined,
-    netbsd: undefined
+export const PLATFORM_MAP = {
+    'aix':'AIX','darwin':'Mac OS','win32':'Windows','android':'Android',
+    'freebsd':'FreeBSD','openbsd':'OpenBSD','sunos':'Solaris','linux':'Linux',
+    'ubuntu':'Ubuntu','ios':'iOS','baileys':'Baileys','chromeos':'Chrome OS',
+    'tizen':'Tizen','watchos':'watchOS','wearos':'Wear OS','harmonyos':'HarmonyOS',
+    'kaios':'KaiOS','smarttv':'Smart TV','raspberrypi':'Raspberry Pi OS',
+    'symbian':'Symbian','blackberry':'Blackberry OS','windowsphone':'Windows Phone'
+};
+export const PLATFORM_VERSIONS = {
+    'ubuntu':'22.04.4','darwin':'18.5','win32':'10.0.22631','android':'14.0.0',
+    'freebsd':'13.2','openbsd':'7.3','sunos':'11','linux':'6.5','ios':'18.2',
+    'baileys':'6.5.0','chromeos':'117.0.5938.132','tizen':'6.5','watchos':'10.1',
+    'wearos':'4.1','harmonyos':'4.0.0','kaios':'3.1','smarttv':'23.3.1',
+    'raspberrypi':'11 (Bullseye)','symbian':'3','blackberry':'10.3.3','windowsphone':'8.1'
 };
 export const Browsers = {
-    ubuntu: browser => ['Ubuntu', browser, '22.04.4'],
-    macOS: browser => ['Mac OS', browser, '14.4.1'],
-    baileys: browser => ['Baileys', browser, '6.5.0'],
-    windows: browser => ['Windows', browser, '10.0.22631'],
-    /** The appropriate browser based on your OS & release */
-    appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', browser, release()]
+    ubuntu: (browser) => [PLATFORM_MAP['ubuntu'], browser, PLATFORM_VERSIONS['ubuntu']],
+    macOS: (browser) => [PLATFORM_MAP['darwin'], browser, PLATFORM_VERSIONS['darwin']],
+    windows: (browser) => [PLATFORM_MAP['win32'], browser, PLATFORM_VERSIONS['win32']],
+    linux: (browser) => [PLATFORM_MAP['linux'], browser, PLATFORM_VERSIONS['linux']],
+    solaris: (browser) => [PLATFORM_MAP['sunos'], browser, PLATFORM_VERSIONS['sunos']],
+    baileys: (browser) => [PLATFORM_MAP['baileys'], browser, PLATFORM_VERSIONS['baileys']],
+    android: (browser) => [PLATFORM_MAP['android'], browser, PLATFORM_VERSIONS['android']],
+    iOS: (browser) => [PLATFORM_MAP['ios'], browser, PLATFORM_VERSIONS['ios']],
+    kaiOS: (browser) => [PLATFORM_MAP['kaios'], browser, PLATFORM_VERSIONS['kaios']],
+    chromeOS: (browser) => [PLATFORM_MAP['chromeos'], browser, PLATFORM_VERSIONS['chromeos']],
+    appropriate: (browser) => {
+        const p = platform();
+        return [PLATFORM_MAP[p] || 'Unknown OS', browser, PLATFORM_VERSIONS[p] || 'latest'];
+    },
+    custom: (p, browser, version) => {
+        return [PLATFORM_MAP[p.toLowerCase()] || p, browser, version || PLATFORM_VERSIONS[p] || 'latest'];
+    }
 };
 export const getPlatformId = (browser) => {
     const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
-    return platformType ? platformType.toString() : '1'; //chrome
+    return platformType ? platformType.toString() : '1';
 };
 //# sourceMappingURL=browser-utils.js.map

package/lib/Utils/generics.js

@@ -1,5 +1,6 @@
 import { Boom } from '@hapi/boom';
 import { createHash, randomBytes } from 'crypto';
+import axios from 'axios';
 import { proto } from '../../WAProto/index.js';
 const baileysVersion = [2, 3000, 1033105955];
 import { DisconnectReason } from '../Types/index.js';
@@ -381,4 +382,30 @@ export function bytesToCrockford(buffer) {
 export function encodeNewsletterMessage(message) {
     return proto.Message.encode(message).finish();
 }
+
+export const COMPANION_PLATFORM_MAP = {
+    'Chrome': '49', 'Edge': '50', 'Firefox': '51', 'Opera': '53', 'Safari': '54',
+    'Brave': '1.79.112', 'Vivaldi': '6.2.3105.58', 'Tor': '12.5.3',
+    'Yandex': '23.7.1', 'Falkon': '22.08.3', 'Epiphany': '44.2'
+};
+// Browsers, PLATFORM_MAP, PLATFORM_VERSIONS, getPlatformId moved to browser-utils.js
+export const printQRIfNecessaryListener = (ev, logger) => {
+    ev.on('connection.update', async ({ qr }) => {
+        if (qr) {
+            const QR = await import('qrcode-terminal').then(m => m.default || m).catch(() => {
+                logger.error('QR code terminal not added as dependency');
+            });
+            QR?.generate(qr, { small: true });
+        }
+    });
+};
+export const toUnicodeEscape = (text) =>
+    text.split('').map(c => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0')).join('');
+export const fromUnicodeEscape = (escapedText) =>
+    escapedText.replace(/\\u[\dA-Fa-f]{4}/g, m => String.fromCharCode(parseInt(m.slice(2), 16)));
+export const asciiEncode = (text) => text.split('').map(c => c.charCodeAt(0));
+export const asciiDecode = (...codes) => {
+    const arr = Array.isArray(codes[0]) ? codes[0] : codes;
+    return arr.map(c => String.fromCharCode(c)).join('');
+};
 //# sourceMappingURL=generics.js.map

package/lib/Utils/index.js

@@ -1,4 +1,6 @@
 export * from './generics.js';
+export * from './audioToBuffer.js';
+export * from './streamToBuffer.js';
 export * from './decode-wa-message.js';
 export * from './messages.js';
 export * from './messages-media.js';
@@ -11,6 +13,9 @@ export * from './chat-utils.js';
 export * from './lt-hash.js';
 export * from './auth-utils.js';
 export * from './use-multi-file-auth-state.js';
+export * from './use-single-file-auth-state.js';
+export * from './use-mongo-file-auth-state.js';
+export * from './baileys-event-stream.js';
 export * from './link-preview.js';
 export * from './event-buffer.js';
 export * from './process-message.js';

package/lib/Utils/messages-media.js

@@ -1,7 +1,9 @@
+import { spawn } from 'child_process';
+import { once } from 'events';
+import { unlink as unlinkFs } from 'fs/promises';
 import { Boom } from '@hapi/boom';
 import { exec } from 'child_process';
 import * as Crypto from 'crypto';
-import { once } from 'events';
 import { createReadStream, createWriteStream, promises as fs, WriteStream } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
@@ -36,7 +38,7 @@ export const getRawMediaUploadData = async (media, mediaType, logger) => {
     const fileWriteStream = createWriteStream(filePath);
     let fileLength = 0;
     try {
-        for await (const data of stream) {
+        for await (const data of finalStream) {
             fileLength += data.length;
             hasher.update(data);
             if (!fileWriteStream.write(data)) {
@@ -306,9 +308,53 @@ export const getHttpStream = async (url, options = {}) => {
     // @ts-ignore Node18+ Readable.fromWeb exists
     return response.body instanceof Readable ? response.body : Readable.fromWeb(response.body);
 };
-export const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts } = {}) => {
+
+// ── convertToOpusBuffer (ported from elaina) ─────────────────────────────────
+const convertToOpusBuffer = (buffer, logger) => new Promise((resolve, reject) => {
+    const args = [
+        '-i', 'pipe:0',
+        '-c:a', 'libopus',
+        '-b:a', '64k',
+        '-vbr', 'on',
+        '-compression_level', '10',
+        '-frame_duration', '20',
+        '-application', 'voip',
+        '-f', 'ogg',
+        'pipe:1'
+    ];
+    const ffmpeg = spawn('ffmpeg', args);
+    const chunks = [];
+    ffmpeg.stdin.write(buffer);
+    ffmpeg.stdin.end();
+    ffmpeg.stdout.on('data', chunk => chunks.push(chunk));
+    ffmpeg.stderr.on('data', () => {});
+    ffmpeg.on('close', code => {
+        if (code === 0) resolve(Buffer.concat(chunks));
+        else reject(new Error(`FFmpeg Opus conversion exited with code ${code}`));
+    });
+    ffmpeg.on('error', err => reject(err));
+});
+// ── End convertToOpusBuffer ───────────────────────────────────────────────────
+
+export const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts, isPtt, forceOpus } = {}) => {
     const { stream, type } = await getStream(media, opts);
     logger?.debug('fetched media stream');
+    let finalStream = stream;
+    let opusConverted = false;
+    // Auto-convert to Opus if PTT or forceOpus
+    if (mediaType === 'audio' && (isPtt === true || forceOpus === true)) {
+        try {
+            const buf = await toBuffer(finalStream);
+            const opusBuf = await convertToOpusBuffer(buf, logger);
+            finalStream = toReadable(opusBuf);
+            opusConverted = true;
+            logger?.debug('converted audio to Opus for PTT');
+        } catch (error) {
+            logger?.error('failed to convert audio to Opus, fallback to original');
+            const { stream: newStream } = await getStream(media, opts);
+            finalStream = newStream;
+        }
+    }
     const mediaKey = Crypto.randomBytes(32);
     const { cipherKey, iv, macKey } = await getMediaKeys(mediaKey, mediaType);
     const encFilePath = join(getTmpFilesDirectory(), mediaType + generateMessageIDV2() + '-enc');
@@ -373,7 +419,8 @@ export const encryptedStream = async (media, mediaType, { logger, saveOriginalFi
             mac,
             fileEncSha256,
             fileSha256,
-            fileLength
+            fileLength,
+            opusConverted
         };
     }
     catch (error) {
@@ -771,4 +818,56 @@ const MEDIA_RETRY_STATUS_MAP = {
     [proto.MediaRetryNotification.ResultType.NOT_FOUND]: 404,
     [proto.MediaRetryNotification.ResultType.GENERAL_ERROR]: 418
 };
+
+export const prepareStream = async (media, mediaType, { logger, saveOriginalFileIfRequired, opts, isPtt, forceOpus } = {}) => {
+    const { stream, type } = await getStream(media, opts);
+    logger?.debug('fetched media stream');
+    let opusConverted = false;
+    let buffer = await toBuffer(stream);
+    // Auto-convert to Opus if PTT or forceOpus
+    if (mediaType === 'audio' && (isPtt === true || forceOpus === true)) {
+        try {
+            const opusBuf = await convertToOpusBuffer(buffer, logger);
+            buffer = opusBuf;
+            opusConverted = true;
+            logger?.debug('converted audio to Opus for newsletter PTT');
+        } catch (e) {
+            logger?.error('failed to convert audio for newsletter PTT');
+        }
+    }
+    const encFilePath = join(tmpdir(), mediaType + generateMessageID() + '-plain');
+    const encFileWriteStream = createWriteStream(encFilePath);
+    let originalFilePath;
+    let originalFileStream;
+    if (type === 'file') {
+        originalFilePath = media.url.toString();
+    } else if (saveOriginalFileIfRequired) {
+        originalFilePath = join(tmpdir(), mediaType + generateMessageID() + '-original');
+        originalFileStream = createWriteStream(originalFilePath);
+    }
+    let fileLength = 0;
+    const hashCtx = createHashCrypto('sha256');
+    try {
+        // Use buffer (possibly opus-converted) directly
+        fileLength = buffer.length;
+        hashCtx.update(buffer);
+        encFileWriteStream.write(buffer);
+        if (originalFileStream) {
+            originalFileStream.write(buffer);
+        }
+        const fileSha256 = hashCtx.digest();
+        encFileWriteStream.end();
+        originalFileStream?.end?.call(originalFileStream);
+        logger?.debug('prepared plain stream successfully');
+        return { mediaKey: undefined, originalFilePath, encFilePath, mac: undefined, fileEncSha256: undefined, fileSha256, fileLength, opusConverted };
+    } catch (error) {
+        encFileWriteStream.destroy();
+        originalFileStream?.destroy?.call(originalFileStream);
+        stream.destroy();
+        try {
+            await unlinkFs(encFilePath);
+        } catch (err) { logger?.error({ err }, 'failed deleting tmp files'); }
+        throw error;
+    }
+};
 //# sourceMappingURL=messages-media.js.map