aunubaileys 1.0.1 → 1.0.2

package/README.md

@@ -58,6 +58,17 @@ sock.ev.on('creds.update', saveCreds)
 
 Everything else is pure upstream. When upstream moves, we rebase the patch layer — that discipline is the whole point of this fork.
 
+
+### 🆕 What's new in 1.0.2 / Baru di 1.0.2
+
+- 📦 **Sticker packs** — send full sticker packs with `stickerPack` (cover + up to 60 stickers).
+- 🖼️ **Album messages** — send grouped photos/videos with `album`.
+- 📣 **Newsletter media fixed** — media uploads to channels use the proper newsletter paths.
+- 🤖 **AI label** — mark bot replies with `ai: true` in private chats.
+- 🔐 **Sturdier connections & sessions** — pre-key upload timeout + atomic session file writes.
+
+**Credits:** features adapted from the community — [@itsliaaa/baileys](https://www.npmjs.com/package/@itsliaaa/baileys) (sticker pack, album, newsletter media, AI label, atomic auth writes), [MichelleBot/baileys](https://github.com/MichelleBot/baileys) (connection fix), [neoxr/baileys](https://github.com/neoxr/baileys) (sticker pack) — merged into AunuBaileys with gratitude. 🙏
+
 ---
 
 ## 🇮🇩 Bahasa Indonesia

package/lib/Defaults/index.js

@@ -64,6 +64,8 @@ export const MEDIA_PATH_MAP = {
     document: '/mms/document',
     audio: '/mms/audio',
     sticker: '/mms/image',
+    'sticker-pack': '/mms/sticker-pack',
+    'thumbnail-sticker-pack': '/mms/thumbnail-sticker-pack',
     'thumbnail-link': '/mms/image',
     'product-catalog-image': '/product/image',
     'md-app-state': '',
@@ -98,4 +100,22 @@ export const DEFAULT_CACHE_TTLS = {
     CALL_OFFER: 5 * 60, // 5 minutes
     USER_DEVICES: 5 * 60 // 5 minutes
 };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map
+// AunuBaileys: peta path upload khusus newsletter (dari @itsliaaa/baileys)
+export const NEWSLETTER_MEDIA_PATH_MAP = {
+    image: '/newsletter/newsletter-image',
+    video: '/newsletter/newsletter-video',
+    audio: '/newsletter/newsletter-audio',
+    document: '/newsletter/newsletter-document',
+    sticker: '/newsletter/newsletter-sticker',
+    gif: '/newsletter/newsletter-gif',
+    ptt: '/newsletter/newsletter-ptt',
+    ptv: '/newsletter/newsletter-ptv',
+    'music-artwork': '/mms/newsletter-music-artwork',
+    'sticker-pack': '/newsletter/newsletter-sticker-pack',
+    'thumbnail-link': '/newsletter/newsletter-thumbnail-link',
+    'waffle-image': '/mms/waffle-image',
+    'waffle-video': '/mms/waffle-video'
+};
+// AunuBaileys: payload label AI (dari @itsliaaa/baileys)
+export const BIZ_BOT_SUPPORT_PAYLOAD = '{"version":1,"is_ai_message":true,"should_upload_client_logs":false,"should_show_system_message":false,"ticket_id":"7004947587700716","citation_items":[],"ticket_locale":"us"}';

package/lib/Socket/messages-send.js

@@ -1,10 +1,10 @@
 import NodeCache from '@cacheable/node-cache';
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
-import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
+import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, delay, extractDeviceJids, generateMessageIDV2, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
-import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isJidGroup, isJidUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isJidGroup, isJidNewsletter, isJidUser, isLidUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeGroupsSocket } from './groups.js';
 import { makeNewsletterSocket } from './newsletter.js';
@@ -654,7 +654,7 @@ export const makeMessagesSocket = (config) => {
                     }),
                     //TODO: CACHE
                     getProfilePicUrl: sock.profilePictureUrl,
-                    upload: waUploadToServer,
+                    upload: (fp, opts) => waUploadToServer(fp, { ...opts, newsletter: isJidNewsletter(jid) }),
                     mediaCache: config.mediaCache,
                     options: config.options,
                     messageId: generateMessageIDV2(sock.user?.id),
@@ -664,6 +664,7 @@ export const makeMessagesSocket = (config) => {
                 const isEditMsg = 'edit' in content && !!content.edit;
                 const isPinMsg = 'pin' in content && !!content.pin;
                 const isPollMessage = 'poll' in content && !!content.poll;
+                const isAiMsg = 'ai' in content && !!content.ai;
                 const additionalAttributes = {};
                 const additionalNodes = [];
                 // required for delete
@@ -690,6 +691,21 @@ export const makeMessagesSocket = (config) => {
                         }
                     });
                 }
+                // AunuBaileys: label AI (dari @itsliaaa/baileys) — hanya chat pribadi
+                else if (isAiMsg) {
+                    if (!(isJidUser(jid) || isLidUser(jid))) {
+                        throw new Boom('AI icon on message are only allowed in private chat', { statusCode: 400 });
+                    }
+                    if (fullMsg.message.messageContextInfo) {
+                        fullMsg.message.messageContextInfo.supportPayload = BIZ_BOT_SUPPORT_PAYLOAD;
+                    }
+                    additionalNodes.push({
+                        tag: 'bot',
+                        attrs: { biz_bot: '1' },
+                        content: undefined
+                    });
+                    delete content.ai;
+                }
                 if ('cachedGroupMetadata' in options) {
                     console.warn('cachedGroupMetadata in sendMessage are deprecated, now cachedGroupMetadata is part of the socket config.');
                 }
@@ -700,6 +716,38 @@ export const makeMessagesSocket = (config) => {
                     statusJidList: options.statusJidList,
                     additionalNodes
                 });
+                // AunuBaileys: kirim isi album sebagai pesan terasosiasi (dari @itsliaaa/baileys)
+                if ('album' in content) {
+                    const { delayMs = 1500 } = options;
+                    for (const albumMedia of content.album) {
+                        const albumMsg = await generateWAMessage(jid, albumMedia, {
+                            logger,
+                            userJid,
+                            upload: (fp, opts) => waUploadToServer(fp, { ...opts, newsletter: isJidNewsletter(jid) }),
+                            mediaCache: config.mediaCache,
+                            options: config.options,
+                            ...options,
+                            messageId: generateMessageIDV2(sock.user?.id)
+                        });
+                        const normalized = normalizeMessageContent(albumMsg.message);
+                        if (!normalized || !('imageMessage' in normalized || 'videoMessage' in normalized)) {
+                            throw new Boom('Invalid message type for album', { statusCode: 400 });
+                        }
+                        albumMsg.message.messageContextInfo = albumMsg.message.messageContextInfo || {};
+                        albumMsg.message.messageContextInfo.messageAssociation = {
+                            parentMessageKey: fullMsg.key,
+                            associationType: proto.MessageAssociation.AssociationType.MEDIA_ALBUM
+                        };
+                        await relayMessage(jid, albumMsg.message, {
+                            messageId: albumMsg.key.id,
+                            useCachedGroupMetadata: options.useCachedGroupMetadata,
+                            statusJidList: options.statusJidList,
+                            additionalAttributes,
+                            additionalNodes
+                        });
+                        await delay(delayMs);
+                    }
+                }
                 if (config.emitOwnEvents) {
                     process.nextTick(() => {
                         processingMutex.mutex(() => upsertMessage(fullMsg, 'append'));

package/lib/Socket/socket.js

@@ -191,7 +191,15 @@ export const makeSocket = (config) => {
         await keys.transaction(async () => {
             logger.info({ count }, 'uploading pre-keys');
             const { update, node } = await getNextPreKeysNode({ creds, keys }, count);
-            await query(node);
+            // AunuBaileys: timeout upload pre-keys agar koneksi tidak menggantung (dari MichelleBot/baileys)
+            await promiseTimeout(30000, async (resolve, reject) => {
+                try {
+                    resolve(await query(node));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
             ev.emit('creds.update', update);
             logger.info({ count }, 'uploaded pre-keys');
         });

package/lib/Types/Message.d.ts

@@ -172,7 +172,22 @@ export type AnyRegularMessageContent = (({
     body?: string;
     footer?: string;
 } | SharePhoneNumber | RequestPhoneNumber) & ViewOnce;
-export type AnyMessageContent = AnyRegularMessageContent | {
+export type StickerPackStickerInfo = {
+    data: WAMediaUpload;
+    emojis?: string[];
+    isAnimated?: boolean;
+    accessibilityLabel?: string;
+    isLottie?: boolean;
+};
+export type StickerPackInfo = {
+    stickers: StickerPackStickerInfo[];
+    cover: WAMediaUpload;
+    name?: string;
+    publisher?: string;
+    packId?: string;
+    description?: string;
+};
+export type AnyMessageContent = (AnyRegularMessageContent | {
     forward: WAMessage;
     force?: boolean;
 } | {
@@ -180,6 +195,22 @@ export type AnyMessageContent = AnyRegularMessageContent | {
     delete: WAMessageKey;
 } | {
     disappearingMessagesInChat: boolean | number;
+} | {
+    /** AunuBaileys: send a sticker pack (cover + stickers) */
+    stickerPack: StickerPackInfo;
+} | {
+    /** AunuBaileys: send a sticker pack, flat form (cover + stickers) */
+    stickers: StickerPackStickerInfo[];
+    cover: WAMediaUpload;
+    name?: string;
+    publisher?: string;
+    description?: string;
+} | {
+    /** AunuBaileys: send an album of images/videos */
+    album: AnyRegularMessageContent[];
+}) & {
+    /** AunuBaileys: mark the message with the AI label (private chats only) */
+    ai?: boolean;
 };
 export type GroupMetadataParticipants = Pick<GroupMetadata, 'participants'>;
 type MinimalRelayOptions = {

package/lib/Utils/messages-media.d.ts

@@ -109,4 +109,5 @@ export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
 }, mediaKey: Uint8Array, msgId: string) => Promise<proto.MediaRetryNotification>;
 export declare const getStatusCodeForMediaRetry: (code: number) => 200 | 412 | 404 | 418;
 export {};
-//# sourceMappingURL=messages-media.d.ts.map
+//# sourceMappingURL=messages-media.d.ts.map
+export declare const getImageProcessingLibrary: () => Promise<Record<string, any>>;

package/lib/Utils/messages-media.js

@@ -9,12 +9,12 @@ import { join } from 'path';
 import { Readable, Transform } from 'stream';
 import { URL } from 'url';
 import { proto } from '../../WAProto/index.js';
-import { DEFAULT_ORIGIN, MEDIA_HKDF_KEY_MAPPING, MEDIA_PATH_MAP } from '../Defaults/index.js';
+import { DEFAULT_ORIGIN, NEWSLETTER_MEDIA_PATH_MAP, MEDIA_HKDF_KEY_MAPPING, MEDIA_PATH_MAP } from '../Defaults/index.js';
 import { getBinaryNodeChild, getBinaryNodeChildBuffer, jidNormalizedUser } from '../WABinary/index.js';
 import { aesDecryptGCM, aesEncryptGCM, hkdf } from './crypto.js';
 import { generateMessageIDV2 } from './generics.js';
 const getTmpFilesDirectory = () => tmpdir();
-const getImageProcessingLibrary = async () => {
+export const getImageProcessingLibrary = async () => {
     //@ts-ignore
     const [jimp, sharp] = await Promise.all([import('jimp').catch(() => { }), import('sharp').catch(() => { })]);
     if (sharp) {
@@ -495,7 +495,7 @@ export function extensionForMediaMessage(message) {
     return extension;
 }
 export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options }, refreshMediaConn) => {
-    return async (filePath, { mediaType, fileEncSha256B64, timeoutMs }) => {
+    return async (filePath, { mediaType, fileEncSha256B64, timeoutMs, newsletter }) => {
         // send a query JSON to obtain the url & auth token to upload our media
         let uploadInfo = await refreshMediaConn(false);
         let urls;
@@ -504,7 +504,14 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
         for (const { hostname } of hosts) {
             logger.debug(`uploading to "${hostname}"`);
             const auth = encodeURIComponent(uploadInfo.auth); // the auth token
-            const url = `https://${hostname}${MEDIA_PATH_MAP[mediaType]}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
+            const mediaPathMap = newsletter ? NEWSLETTER_MEDIA_PATH_MAP : MEDIA_PATH_MAP;
+            let url = `https://${hostname}${mediaPathMap[mediaType]}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
+            if (newsletter) {
+                url += '&server_thumb_gen=1';
+                if (mediaType === 'video' || mediaType === 'gif' || mediaType === 'ptv') {
+                    url += '&server_transcode=1';
+                }
+            }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             let result;
             try {

package/lib/Utils/messages.js

@@ -3,13 +3,14 @@ import axios from 'axios';
 import { randomBytes } from 'crypto';
 import { promises as fs } from 'fs';
 import {} from 'stream';
+import { zip } from 'fflate';
 import { proto } from '../../WAProto/index.js';
 import { MEDIA_KEYS, URL_REGEX, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
 import { WAMessageStatus, WAProto } from '../Types/index.js';
 import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
-import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData } from './messages-media.js';
+import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData, getImageProcessingLibrary, getStream, toBuffer } from './messages-media.js';
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
     video: 'video/mp4',
@@ -257,6 +258,205 @@ export const generateForwardMessageContent = (message, forceForward) => {
     }
     return content;
 };
+// AunuBaileys: StickerPack (diadaptasi dari neoxr/baileys & @itsliaaa/baileys)
+function isWebPBuffer(buffer) {
+    return (buffer.length >= 12 &&
+        buffer[0] === 0x52 &&
+        buffer[1] === 0x49 &&
+        buffer[2] === 0x46 &&
+        buffer[3] === 0x46 &&
+        buffer[8] === 0x57 &&
+        buffer[9] === 0x45 &&
+        buffer[10] === 0x42 &&
+        buffer[11] === 0x50);
+}
+function isAnimatedWebP(buffer) {
+    // WebP must start with RIFF....WEBP
+    if (buffer.length < 12 ||
+        buffer[0] !== 0x52 ||
+        buffer[1] !== 0x49 ||
+        buffer[2] !== 0x46 ||
+        buffer[3] !== 0x46 ||
+        buffer[8] !== 0x57 ||
+        buffer[9] !== 0x45 ||
+        buffer[10] !== 0x42 ||
+        buffer[11] !== 0x50) {
+        return false;
+    }
+    // Parse chunks starting after RIFF header (12 bytes)
+    let offset = 12;
+    while (offset < buffer.length - 8) {
+        const chunkFourCC = buffer.toString('ascii', offset, offset + 4);
+        const chunkSize = buffer.readUInt32LE(offset + 4);
+        if (chunkFourCC === 'VP8X') {
+            // VP8X extended header, check animation flag (bit 1 at offset+8)
+            const flagsOffset = offset + 8;
+            if (flagsOffset < buffer.length) {
+                const flags = buffer[flagsOffset];
+                if (flags & 0x02) {
+                    return true;
+                }
+            }
+        }
+        else if (chunkFourCC === 'ANIM' || chunkFourCC === 'ANMF') {
+            // ANIM or ANMF chunks indicate animation
+            return true;
+        }
+        // Move to next chunk (chunk size + 8 bytes header, padded to even)
+        offset += 8 + chunkSize + (chunkSize % 2);
+    }
+    return false;
+}
+async function prepareStickerPackMessage(stickerPack, options) {
+    const { stickers, name, publisher, packId, description } = stickerPack;
+    if (stickers.length > 60) {
+        throw new Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
+    }
+    if (stickers.length === 0) {
+        throw new Boom('Sticker pack must contain at least one sticker', { statusCode: 400 });
+    }
+    const stickerPackIdValue = packId || generateMessageIDV2();
+    const lib = await getImageProcessingLibrary();
+    const stickerData = {};
+    const stickerPromises = stickers.map(async (s, i) => {
+        try {
+            const { stream } = await getStream(s.data);
+            const buffer = await toBuffer(stream);
+            let webpBuffer;
+            let isAnimated = false;
+            const isWebP = isWebPBuffer(buffer);
+            if (isWebP) {
+                // Already WebP - preserve original to keep exif metadata and animation
+                webpBuffer = buffer;
+                isAnimated = isAnimatedWebP(buffer);
+            }
+            else if ('sharp' in lib && lib.sharp) {
+                // Convert to WebP, preserving metadata
+                webpBuffer = await lib.sharp.default(buffer).webp().toBuffer();
+                // Non-WebP inputs converted to WebP are not animated
+                isAnimated = false;
+            }
+            else {
+                throw new Boom('No image processing library (sharp) available for converting sticker to WebP. Either install sharp or provide stickers in WebP format.');
+            }
+            if (webpBuffer.length > 1024 * 1024) {
+                throw new Boom(`Sticker at index ${i} exceeds the 1MB size limit`, { statusCode: 400 });
+            }
+            const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-');
+            const fileName = `${hash}.webp`;
+            stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 0 }];
+            return {
+                fileName,
+                mimetype: 'image/webp',
+                isAnimated: s.isAnimated || isAnimated,
+                emojis: s.emojis || [],
+                accessibilityLabel: s.accessibilityLabel || '',
+                isLottie: s.isLottie || false
+            };
+        }
+        catch (e) {
+            options.logger?.warn(`Skipping sticker ${i}: ${e.message}`);
+            return null;
+        }
+    });
+    const stickerMetadata = (await Promise.all(stickerPromises)).filter(Boolean);
+    // Process and add cover/tray icon to the ZIP
+    const trayIconFileName = `${stickerPackIdValue}.webp`;
+    const { stream: coverStream } = await getStream(stickerPack.cover);
+    const coverBuffer = await toBuffer(coverStream);
+    let coverWebpBuffer;
+    const isCoverWebP = isWebPBuffer(coverBuffer);
+    if (isCoverWebP) {
+        // Already WebP - preserve original to keep exif metadata
+        coverWebpBuffer = coverBuffer;
+    }
+    else if ('sharp' in lib && lib.sharp) {
+        coverWebpBuffer = await lib.sharp.default(coverBuffer).webp().toBuffer();
+    }
+    else {
+        throw new Boom('No image processing library (sharp) available for converting cover to WebP. Either install sharp or provide cover in WebP format.');
+    }
+    // Add cover to ZIP data
+    stickerData[trayIconFileName] = [new Uint8Array(coverWebpBuffer), { level: 0 }];
+    const zipBuffer = await new Promise((resolve, reject) => {
+        zip(stickerData, (err, data) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(Buffer.from(data));
+            }
+        });
+    });
+    const stickerPackSize = zipBuffer.length;
+    const stickerPackUpload = await encryptedStream(zipBuffer, 'sticker-pack', {
+        logger: options.logger,
+        opts: options.options
+    });
+    const stickerPackUploadResult = await options.upload(stickerPackUpload.encFilePath, {
+        fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+        mediaType: 'sticker-pack',
+        timeoutMs: options.mediaUploadTimeoutMs
+    });
+    await fs.unlink(stickerPackUpload.encFilePath);
+    const stickerPackMessage = {
+        name: name,
+        publisher: publisher,
+        stickerPackId: stickerPackIdValue,
+        packDescription: description,
+        stickerPackOrigin: WAProto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
+        stickerPackSize: stickerPackSize,
+        stickers: stickerMetadata,
+        fileSha256: stickerPackUpload.fileSha256,
+        fileEncSha256: stickerPackUpload.fileEncSha256,
+        mediaKey: stickerPackUpload.mediaKey,
+        directPath: stickerPackUploadResult.directPath,
+        fileLength: stickerPackUpload.fileLength,
+        mediaKeyTimestamp: unixTimestampSeconds(),
+        trayIconFileName: trayIconFileName
+    };
+    try {
+        // Reuse the cover buffer we already processed for thumbnail generation
+        let thumbnailBuffer;
+        if ('sharp' in lib && lib.sharp) {
+            thumbnailBuffer = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg().toBuffer();
+        }
+        else if ('jimp' in lib && lib.jimp) {
+            const jimpImage = await lib.jimp.Jimp.read(coverBuffer);
+            thumbnailBuffer = await jimpImage.resize({ w: 252, h: 252 }).getBuffer('image/jpeg');
+        }
+        else {
+            throw new Error('No image processing library available for thumbnail generation');
+        }
+        if (!thumbnailBuffer || thumbnailBuffer.length === 0) {
+            throw new Error('Failed to generate thumbnail buffer');
+        }
+        const thumbUpload = await encryptedStream(thumbnailBuffer, 'thumbnail-sticker-pack', {
+            logger: options.logger,
+            opts: options.options,
+            mediaKey: stickerPackUpload.mediaKey // Use same mediaKey as the sticker pack ZIP
+        });
+        const thumbUploadResult = await options.upload(thumbUpload.encFilePath, {
+            fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
+            mediaType: 'thumbnail-sticker-pack',
+            timeoutMs: options.mediaUploadTimeoutMs
+        });
+        await fs.unlink(thumbUpload.encFilePath);
+        Object.assign(stickerPackMessage, {
+            thumbnailDirectPath: thumbUploadResult.directPath,
+            thumbnailSha256: thumbUpload.fileSha256,
+            thumbnailEncSha256: thumbUpload.fileEncSha256,
+            thumbnailHeight: 252,
+            thumbnailWidth: 252,
+            imageDataHash: sha256(thumbnailBuffer).toString('base64')
+        });
+    }
+    catch (e) {
+        options.logger?.warn?.(`Thumbnail generation failed: ${e}`);
+    }
+    return { stickerPackMessage };
+}
+
 export const generateWAMessageContent = async (message, options) => {
     var _a, _b;
     let m = {};
@@ -434,6 +634,28 @@ export const generateWAMessageContent = async (message, options) => {
     else if ('requestPhoneNumber' in message) {
         m.requestPhoneNumberMessage = {};
     }
+    else if ('album' in message) {
+        // AunuBaileys: album message (dari @itsliaaa/baileys)
+        if (!Array.isArray(message.album)) {
+            throw new Boom('Invalid album type. Expected an array.', { statusCode: 400 });
+        }
+        let videoCount = 0;
+        let imageCount = 0;
+        for (const item of message.album) {
+            if (item.video) videoCount++;
+            if (item.image) imageCount++;
+        }
+        if (videoCount + imageCount < 2) {
+            throw new Boom('Minimum provide 2 media to upload album message', { statusCode: 400 });
+        }
+        m.albumMessage = { expectedImageCount: imageCount, expectedVideoCount: videoCount };
+    }
+    else if ('stickerPack' in message) {
+        m = await prepareStickerPackMessage(message.stickerPack, options);
+    }
+    else if ('stickers' in message && 'cover' in message) {
+        m = await prepareStickerPackMessage(message, options);
+    }
     else {
         m = await prepareWAMessageMedia(message, options);
     }

package/lib/Utils/use-multi-file-auth-state.js

@@ -1,5 +1,5 @@
 import { Mutex } from 'async-mutex';
-import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
+import { mkdir, readFile, rename, stat, unlink, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { proto } from '../../WAProto/index.js';
 import { initAuthCreds } from './auth-utils.js';
@@ -32,7 +32,10 @@ export const useMultiFileAuthState = async (folder) => {
         const mutex = getFileLock(filePath);
         return mutex.acquire().then(async (release) => {
             try {
-                await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
+                // AunuBaileys: atomic write (tmp + rename) anti-korupsi sesi — terinspirasi @itsliaaa/baileys
+                const tmpPath = `${filePath}.tmp-${process.pid}`;
+                await writeFile(tmpPath, JSON.stringify(data, BufferJSON.replacer));
+                await rename(tmpPath, filePath);
             }
             finally {
                 release();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "AunuBaileys \u2014 a WhatsApp Web API for bots that never sleep. Full upstream power with the beloved in-memory store restored and pairing that just works. Forged by AunuCore.",
   "keywords": [
     "whatsapp",
@@ -46,7 +46,8 @@
     "pino": "^9.6",
     "protobufjs": "^7.2.4",
     "ws": "^8.13.0",
-    "@adiwajshing/keyed-db": "^0.2.4"
+    "@adiwajshing/keyed-db": "^0.2.4",
+    "fflate": "^0.8.2"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",