@blckrose/baileys 1.0.0 → 1.0.5

package/lib/Types/index.js

@@ -1,4 +1,5 @@
 export * from './Auth.js';
+export * from './MexUpdates.js';
 export * from './GroupMetadata.js';
 export * from './Chat.js';
 export * from './Contact.js';

package/lib/Utils/audioToBuffer.js

@@ -0,0 +1,31 @@
+import { Buffer } from 'buffer';
+import fs from 'fs/promises';
+import { Readable } from 'stream';
+import { streamToBuffer } from './streamToBuffer.js';
+
+/**
+ * Mengonversi berbagai input audio (Buffer, URL, path file, atau Readable stream) menjadi Buffer.
+ * @param {Buffer|string|Readable} audio Input audio.
+ * @returns {Promise<Buffer>} Buffer hasil konversi.
+ */
+async function audioToBuffer(audio) {
+    if (Buffer.isBuffer(audio)) {
+        return audio;
+    }
+
+    if (typeof audio === 'string') {
+        if (/^https?:\/\//.test(audio)) {
+            const res = await fetch(audio); // native fetch bawaan Node 20
+            return Buffer.from(await res.arrayBuffer());
+        }
+        return fs.readFile(audio);
+    }
+
+    if (audio instanceof Readable) {
+        return streamToBuffer(audio);
+    }
+
+    throw new TypeError('Unsupported audio input type');
+}
+
+export { audioToBuffer };

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';
@@ -771,4 +773,45 @@ 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 } = {}) => {
+    const { stream, type } = await getStream(media, opts);
+    logger?.debug('fetched media stream');
+    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 {
+        for await (const data of stream) {
+            fileLength += data.length;
+            hashCtx.update(data);
+            encFileWriteStream.write(data);
+            if (originalFileStream && !originalFileStream.write(data)) {
+                await once(originalFileStream, 'drain');
+            }
+        }
+        const fileSha256 = hashCtx.digest();
+        encFileWriteStream.end();
+        originalFileStream?.end?.call(originalFileStream);
+        stream.destroy();
+        logger?.debug('prepared plain stream successfully');
+        return { mediaKey: undefined, originalFilePath, encFilePath, mac: undefined, fileEncSha256: undefined, fileSha256, fileLength };
+    } 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