aunubaileys 1.0.1 → 1.0.3

package/README.md

@@ -58,6 +58,24 @@ 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.3 / Baru di 1.0.3
+
+- ⚡ **Modern core** — latest WA version `2.3000.1035194821`, 812 pre-keys, tuned WebSocket (no per-message deflate, 100 MB payload).
+- 🧩 **More message types** — quiz polls (newsletter), poll result snapshots, poll updates, payment invites, order messages.
+- 🛠️ **Developer API** — `sock.aunuHandler` (send/reply/react helpers), `fetchAccountReachoutTimelock()`, `fetchNewChatMessageCap()`, `registerSocketEndHandler()`, `newsletterId()` helper.
+
+### 🆕 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/baileys-version.json

@@ -1,3 +1,3 @@
 {
-    "version": [2, 3000, 1043857760]
+    "version": [2, 3000, 1035194821]
 }

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': '',
@@ -91,11 +93,29 @@ export const MEDIA_HKDF_KEY_MAPPING = {
 };
 export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
 export const MIN_PREKEY_COUNT = 5;
-export const INITIAL_PREKEY_COUNT = 30;
+export const INITIAL_PREKEY_COUNT = 812;
 export const DEFAULT_CACHE_TTLS = {
     SIGNAL_STORE: 5 * 60, // 5 minutes
     MSG_RETRY: 60 * 60, // 1 hour
     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/Client/websocket.js

@@ -23,6 +23,9 @@ export class WebSocketClient extends AbstractSocketClient {
             return;
         }
         this.socket = new WebSocket(this.url, {
+            // AunuBaileys: stabilitas WS — tanpa kompresi per-message, payload besar aman
+            perMessageDeflate: false,
+            maxPayload: 100 * 1024 * 1024,
             origin: DEFAULT_ORIGIN,
             headers: this.config.options?.headers,
             handshakeTimeout: this.config.connectTimeoutMs,

package/lib/Socket/index.js

@@ -1,5 +1,6 @@
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
 import { makeCommunitiesSocket } from './communities.js';
+import { AunuHandler } from '../Utils/aunu-handler.js';
 // export the last socket layer
 const makeWASocket = (config) => {
     const newConfig = {
@@ -11,7 +12,9 @@ const makeWASocket = (config) => {
     if (config.shouldSyncHistoryMessage === undefined) {
         newConfig.shouldSyncHistoryMessage = () => !!newConfig.syncFullHistory;
     }
-    return makeCommunitiesSocket(newConfig);
+    const sock = makeCommunitiesSocket(newConfig);
+    sock.aunuHandler = new AunuHandler(sock);
+    return sock;
 };
 export default makeWASocket;
 //# sourceMappingURL=index.js.map

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/newsletter.js

@@ -1,3 +1,4 @@
+import Boom from '@hapi/boom';
 import { QueryIds, XWAPaths } from '../Types/index.js';
 import { generateProfilePicture } from '../Utils/messages-media.js';
 import { getBinaryNodeChild } from '../WABinary/index.js';
@@ -49,6 +50,13 @@ export const makeNewsletterSocket = (sock) => {
     };
     return {
         ...sock,
+        // AunuBaileys: ambil ID numerik dari JID newsletter
+        newsletterId: (jid) => {
+            if (!jid || !jid.endsWith('@newsletter')) {
+                throw new Boom('Invalid newsletter jid', { statusCode: 400 });
+            }
+            return jid.split('@')[0];
+        },
         newsletterCreate: async (name, description) => {
             const variables = {
                 input: {

package/lib/Socket/socket.js

@@ -4,7 +4,9 @@ import { URL } from 'url';
 import { promisify } from 'util';
 import { proto } from '../../WAProto/index.js';
 import { DEF_CALLBACK_PREFIX, DEF_TAG_PREFIX, INITIAL_PREKEY_COUNT, MIN_PREKEY_COUNT, NOISE_WA_HEADER } from '../Defaults/index.js';
-import { DisconnectReason } from '../Types/index.js';
+import { DisconnectReason } from '../Types/index.js'
+import { executeWMexQuery } from './mex.js';
+import { QueryIds, XWAPaths } from '../Types/index.js';
 import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getErrorCodeFromStreamError, getNextPreKeysNode, getPlatformId, makeEventBuffer, makeNoiseHandler, promiseTimeout } from '../Utils/index.js';
 import { assertNodeErrorFree, binaryNodeToString, encodeBinaryNode, getBinaryNodeChild, getBinaryNodeChildren, jidEncode, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { WebSocketClient } from './Client/index.js';
@@ -191,7 +193,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');
         });
@@ -234,6 +244,11 @@ export const makeSocket = (config) => {
             }
         });
     };
+    // AunuBaileys: socket end handlers (pola v7) + fetch Mex (dari @itsliaaa/baileys)
+    const socketEndHandlers = [];
+    const registerSocketEndHandler = (handler) => {
+        socketEndHandlers.push(handler);
+    };
     const end = (error) => {
         if (closed) {
             logger.trace({ trace: error?.stack }, 'connection already closed');
@@ -259,6 +274,12 @@ export const makeSocket = (config) => {
                 date: new Date()
             }
         });
+        for (const handler of socketEndHandlers) {
+            try {
+                handler();
+            }
+            catch { }
+        }
         ev.removeAllListeners('connection.update');
     };
     const waitForSocketOpen = async () => {
@@ -569,6 +590,21 @@ export const makeSocket = (config) => {
         }
         Object.assign(creds, update);
     });
+    const fetchAccountReachoutTimelock = async () => {
+        const queryResult = await executeWMexQuery({}, QueryIds.REACHOUT_TIMELOCK, XWAPaths.xwa2_fetch_account_reachout_timelock, query, generateMessageTag);
+        const result = {
+            isActive: !!queryResult?.is_active,
+            timeEnforcementEnds: queryResult?.time_enforcement_ends && queryResult?.time_enforcement_ends !== '0'
+                ? new Date(parseInt(queryResult.time_enforcement_ends, 10) * 1000)
+                : undefined,
+            enforcementType: queryResult?.enforcement_type ?? 'DEFAULT'
+        };
+        ev.emit('connection.update', { reachoutTimeLock: result });
+        return result;
+    };
+    const fetchNewChatMessageCap = async () => {
+        return executeWMexQuery({ input: { type: 'INDIVIDUAL_NEW_CHAT_MSG' } }, QueryIds.MESSAGE_CAPPING_INFO, XWAPaths.xwa2_message_capping_info, query, generateMessageTag);
+    };
     return {
         type: 'md',
         ws,
@@ -586,6 +622,9 @@ export const makeSocket = (config) => {
         sendNode,
         logout,
         end,
+        registerSocketEndHandler,
+        fetchAccountReachoutTimelock,
+        fetchNewChatMessageCap,
         onUnexpectedError,
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,

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/Types/Newsletter.js

@@ -12,6 +12,8 @@ export var XWAPaths;
     XWAPaths["xwa2_newsletter_change_owner"] = "xwa2_newsletter_change_owner";
     XWAPaths["xwa2_newsletter_demote"] = "xwa2_newsletter_demote";
     XWAPaths["xwa2_newsletter_delete_v2"] = "xwa2_newsletter_delete_v2";
+    XWAPaths["xwa2_fetch_account_reachout_timelock"] = "xwa2_fetch_account_reachout_timelock";
+    XWAPaths["xwa2_message_capping_info"] = "xwa2_message_capping_info";
 })(XWAPaths || (XWAPaths = {}));
 export var QueryIds;
 (function (QueryIds) {
@@ -27,5 +29,7 @@ export var QueryIds;
     QueryIds["CHANGE_OWNER"] = "7341777602580933";
     QueryIds["DEMOTE"] = "6551828931592903";
     QueryIds["DELETE"] = "30062808666639665";
+    QueryIds["REACHOUT_TIMELOCK"] = "23983697327930364";
+    QueryIds["MESSAGE_CAPPING_INFO"] = "24503548349331633";
 })(QueryIds || (QueryIds = {}));
 //# sourceMappingURL=Newsletter.js.map

package/lib/Utils/aunu-handler.d.ts

@@ -0,0 +1,11 @@
+import type { AnyMessageContent, MiscMessageGenerationOptions, WAMessage, WASocket } from '../Types';
+export declare class AunuHandler {
+    sock: WASocket;
+    readonly name: string;
+    readonly brand: string;
+    constructor(sock: WASocket);
+    send(jid: string, content: AnyMessageContent, options?: MiscMessageGenerationOptions): Promise<WAMessage | undefined>;
+    reply(jid: string, content: AnyMessageContent, quoted: WAMessage, options?: MiscMessageGenerationOptions): Promise<WAMessage | undefined>;
+    react(jid: string, emoji: string, key: WAMessage['key']): Promise<WAMessage | undefined>;
+    newsletterId(jid: string): string;
+}

package/lib/Utils/aunu-handler.js

@@ -0,0 +1,27 @@
+/**
+ * AunuHandler — lapisan kenyamanan khas AunuBaileys di atas socket.
+ * Diekspos sebagai `sock.aunuHandler` dan diekspor sebagai kelas dari paket.
+ */
+export class AunuHandler {
+    constructor(sock) {
+        this.sock = sock;
+        this.name = 'AunuBaileys';
+        this.brand = 'AunuCore Creative Network';
+    }
+    /** Kirim pesan apa pun (delegate ke sock.sendMessage). */
+    async send(jid, content, options) {
+        return this.sock.sendMessage(jid, content, options);
+    }
+    /** Balas sebuah pesan (quote). */
+    async reply(jid, content, quoted, options = {}) {
+        return this.sock.sendMessage(jid, content, { ...options, quoted });
+    }
+    /** Beri reaksi emoji ke sebuah pesan. */
+    async react(jid, emoji, key) {
+        return this.sock.sendMessage(jid, { react: { text: emoji, key } });
+    }
+    /** ID numerik dari JID newsletter. */
+    newsletterId(jid) {
+        return this.sock.newsletterId(jid);
+    }
+}

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 = {};
@@ -415,6 +615,23 @@ export const generateWAMessageContent = async (message, options) => {
             // poll v2 is for community announcement groups (single select and multiple)
             m.pollCreationMessageV2 = pollCreationMessage;
         }
+        else if (message.poll.pollType === 1) {
+            // AunuBaileys: kuis (dari @itsliaaa/baileys) — untuk newsletter
+            if (!message.poll.correctAnswer) {
+                throw new Boom('No "correctAnswer" provided for quiz', { statusCode: 400 });
+            }
+            // proto 6.7.24: V5 adalah FutureProofMessage — konten dibungkus di .message
+            m.pollCreationMessageV5 = {
+                message: {
+                    pollCreationMessage: {
+                        ...pollCreationMessage,
+                        correctAnswer: { optionName: message.poll.correctAnswer.toString() },
+                        pollType: 1,
+                        selectableOptionsCount: 1
+                    }
+                }
+            };
+        }
         else {
             if (message.poll.selectableCount === 1) {
                 //poll v3 is for single select polls
@@ -426,6 +643,62 @@ export const generateWAMessageContent = async (message, options) => {
             }
         }
     }
+    else if ('pollResult' in message) {
+        // AunuBaileys: poll result snapshot (dari @itsliaaa/baileys)
+        const pollResultSnapshotMessage = {
+            name: message.pollResult.name,
+            pollVotes: message.pollResult.votes.map(vote => ({
+                optionName: vote.name,
+                optionVoteCount: parseInt(vote.voteCount)
+            }))
+        };
+        if (message.pollResult.pollType === 1) {
+            pollResultSnapshotMessage.pollType = proto.Message.PollCreationMessage.PollType.QUIZ;
+            m.pollResultSnapshotMessageV3 = pollResultSnapshotMessage;
+        }
+        else {
+            pollResultSnapshotMessage.pollType = proto.Message.PollCreationMessage.PollType.POLL;
+            m.pollResultSnapshotMessage = pollResultSnapshotMessage;
+        }
+    }
+    else if ('pollUpdate' in message) {
+        if (!message.pollUpdate.key) {
+            throw new Boom('Message key is required', { statusCode: 400 });
+        }
+        if (!message.pollUpdate.vote) {
+            throw new Boom('Encrypted vote payload is required', { statusCode: 400 });
+        }
+        m.pollUpdateMessage = {
+            metadata: message.pollUpdate.metadata,
+            pollCreationMessageKey: message.pollUpdate.key,
+            senderTimestampMs: Date.now(),
+            vote: message.pollUpdate.vote
+        };
+    }
+    else if ('paymentInviteServiceType' in message) {
+        // AunuBaileys: payment invite (dari @itsliaaa/baileys)
+        m.paymentInviteMessage = {
+            expiryTimestamp: Date.now(),
+            serviceType: message.paymentInviteServiceType
+        };
+    }
+    else if ('orderText' in message) {
+        // AunuBaileys: order message (dari @itsliaaa/baileys)
+        if (message.thumbnail !== undefined && !Buffer.isBuffer(message.thumbnail)) {
+            throw new Boom('Must provide thumbnail buffer in order message', { statusCode: 400 });
+        }
+        m.orderMessage = {
+            itemCount: message.itemCount || 1,
+            messageVersion: 1,
+            orderTitle: message.orderTitle || 'AunuBaileys',
+            status: proto.Message.OrderMessage.OrderStatus.INQUIRY,
+            surface: proto.Message.OrderMessage.OrderSurface.CATALOG,
+            totalAmount1000: message.totalAmount1000 || 1000,
+            totalCurrencyCode: message.currency || 'IDR',
+            thumbnail: message.thumbnail,
+            message: message.orderText
+        };
+    }
     else if ('sharePhoneNumber' in message) {
         m.protocolMessage = {
             type: proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER
@@ -434,6 +707,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/lib/index.d.ts

@@ -13,3 +13,4 @@ export default makeWASocket;
 export * from './Store/index.js';
 export { processedMessages, initInMemoryKeyStore } from './Utils/fork-compat.js';
 export { PHONENUMBER_MCC } from './Utils/phonenumber-mcc.js';
+export * from './Utils/aunu-handler';

package/lib/index.js

@@ -12,3 +12,4 @@ export default makeWASocket;
 export * from './Store/index.js';
 export { processedMessages, initInMemoryKeyStore } from './Utils/fork-compat.js';
 export { PHONENUMBER_MCC } from './Utils/phonenumber-mcc.js';
+export * from './Utils/aunu-handler.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "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",