@aunucore/baileys 1.0.86 → 1.0.87

package/lib/Socket/chats.js

@@ -82,8 +82,30 @@ export const makeChatsSocket = (config) => {
         // AunuBaileys (1.0.71): a privacy change is a settings change —
         // refetch the full set (the cached copy is now stale) and publish
         // it (donor event: violetix 'privacy.update' on account_sync).
-        privacySettings = await fetchPrivacySettings(true);
-        ev.emit('privacy.update', privacySettings);
+        // AunuBaileys (1.0.87, HB-163): the SET above has already
+        // been applied by the server when this refetch runs. A
+        // refetch failure used to reject the whole privacyQuery —
+        // the caller saw a failed update that had in fact taken
+        // effect, the cache kept the OLD value, and readMessages
+        // derived its receipt type from that stale cache (sending
+        // 'read' receipts against a receipts setting the user had
+        // just switched off). Make the refetch best-effort: on
+        // failure, fold the applied change into the cached copy so
+        // cache and event reflect what the server now holds for
+        // this key. Never fabricate a partial cache when none
+        // exists — that would suppress the next full fetch.
+        try {
+            privacySettings = await fetchPrivacySettings(true);
+        }
+        catch (err) {
+            logger.warn({ err, name, value }, 'failed to refetch privacy settings after a successful set; folding the change into the cached copy');
+            if (privacySettings) {
+                privacySettings = { ...privacySettings, [name]: value };
+            }
+        }
+        if (privacySettings) {
+            ev.emit('privacy.update', privacySettings);
+        }
     };
     const updateMessagesPrivacy = async (value) => {
         await privacyQuery('messages', value);
@@ -946,11 +968,35 @@ export const makeChatsSocket = (config) => {
         const doAppStateSync = async () => {
             if (syncState === SyncState.Syncing) {
                 logger.info('Doing app state sync');
-                await resyncAppState(ALL_WA_PATCH_NAMES, true);
-                // Sync is complete, go online and flush everything
+                // AunuBaileys (1.0.87, HB-241): resyncAppState can
+                // throw OUTSIDE its per-collection handling — the
+                // sync IQ itself, a malformed blob in
+                // extractSyncdPatches, the resync-round cap. That
+                // throw used to reject upsertMessage and leave
+                // syncState at Syncing for the rest of the session:
+                // the full initial sync was never retried (nothing
+                // re-triggers it) and the state machine never
+                // reached Online. A failed sync must END the
+                // Syncing state, not freeze it — go Online and
+                // flush either way, and only count the sync as
+                // complete (the accountSyncCounter advance below)
+                // when it actually succeeded.
+                let syncFailed = false;
+                try {
+                    await resyncAppState(ALL_WA_PATCH_NAMES, true);
+                }
+                catch (err) {
+                    syncFailed = true;
+                    logger.error({ err }, 'app state sync failed; transitioning to Online state anyway');
+                }
+                // Sync ran its course, go online and flush everything
                 syncState = SyncState.Online;
                 logger.info('App state sync complete, transitioning to Online state and flushing buffer');
                 ev.flush();
+                // (HB-241) a failed sync is not a completed one:
+                // do not advance the counter that signals the
+                // initial sync finished.
+                if (!syncFailed) {
                 const accountSyncCounter = (authState.creds.accountSyncCounter || 0) + 1;
                 // AunuBaileys (1.0.81, HB-257): same guard as the
                 // pushName emit above — a throwing 'creds.update'
@@ -963,6 +1009,7 @@ export const makeChatsSocket = (config) => {
                 catch (err) {
                     onUnexpectedError(err, 'creds.update (accountSyncCounter)');
                 }
+                }
             }
         };
         await Promise.all([

package/lib/Socket/messages-recv.js

@@ -1771,7 +1771,14 @@ export const makeMessagesRecvSocket = (config) => {
         }
         const operation = data?.operation;
         const updates = data?.updates;
-        if (!updates || !operation) {
+        // AunuBaileys (1.0.87, HB-121): this guard used to be a
+        // truthiness check only — a MEX payload whose `updates`
+        // is a non-array (object/number/boolean) passed it, and
+        // the for...of loops in every switch branch below threw a
+        // TypeError, silently dropping the whole notification
+        // (handleNotification acks the stanza in its finally
+        // either way, so nothing ever retried it).
+        if (!Array.isArray(updates) || !operation) {
             logger.warn({ data }, 'Invalid mex newsletter notification content');
             return;
         }

package/lib/Socket/mex.js

@@ -22,11 +22,29 @@ export const executeWMexQuery = async (variables, queryId, dataPath, query, gene
     const result = await wMexQuery(variables, queryId, query, generateMessageTag);
     const child = getBinaryNodeChild(result, 'result');
     if (child?.content) {
-        const data = JSON.parse(child.content.toString());
+        // AunuBaileys (1.0.87, HB-211): a <result> that is not JSON
+        // (including a child-node array body, which stringifies to
+        // "[object Object]") used to reject with a raw SyntaxError
+        // the host could not classify.
+        let data;
+        try {
+            data = JSON.parse(child.content.toString());
+        }
+        catch (err) {
+            throw new Boom('GraphQL server error: unparseable response', { statusCode: 400, data: result });
+        }
         if (data.errors && data.errors.length > 0) {
             const errorMessages = data.errors.map((err) => err.message || 'Unknown error').join(', ');
             const firstError = data.errors[0];
-            const errorCode = firstError.extensions?.error_code || 400;
+            // AunuBaileys (1.0.87, HB-211): the server's error_code
+            // went into the Boom constructor unsanitised — a string
+            // code ('RATE_LIMITED') or an out-of-range one (200)
+            // made `new Boom` itself throw a non-Boom TypeError,
+            // and the server's actual error message was lost with
+            // it. Same sanitation as HB-42: only a numeric HTTP
+            // error code survives, everything else becomes 400.
+            const rawErrorCode = firstError.extensions?.error_code;
+            const errorCode = typeof rawErrorCode === 'number' && rawErrorCode >= 400 && rawErrorCode <= 599 ? rawErrorCode : 400;
             throw new Boom(`GraphQL server error: ${errorMessages}`, { statusCode: errorCode, data: firstError });
         }
         const response = dataPath ? data?.data?.[dataPath] : data?.data;

package/lib/Utils/aunu-message-inspect.js

@@ -37,31 +37,37 @@ import { jidDecode } from '../WABinary/index.js';
 import { getKeyAuthor } from './generics.js';
 import { getAggregateVotesInPollMessage, normalizeMessageContent } from './messages.js';
 
+// AunuBaileys (1.0.87, HB-218): every operand is optional-chained,
+// exactly like the base getFutureProofMessage in messages.js. A
+// wrapper whose `message` field is absent decodes with message ===
+// null; the bare derefs used to throw a raw TypeError on the next
+// loop iteration of normalizeAunuMessageContentExtended (and in
+// getAggregateVotesInPollMessageExtended downstream of it).
 const getFutureProofMessageExtended = (message) => (
-    message.ephemeralMessage ||
-    message.viewOnceMessage ||
-    message.documentWithCaptionMessage ||
-    message.viewOnceMessageV2 ||
-    message.viewOnceMessageV2Extension ||
-    message.editedMessage ||
-    message.groupMentionedMessage ||
-    message.botInvokeMessage ||
-    message.lottieStickerMessage ||
-    message.eventCoverImage ||
-    message.statusMentionMessage ||
-    message.pollCreationOptionImageMessage ||
-    message.associatedChildMessage ||
-    message.groupStatusMentionMessage ||
-    message.pollCreationMessageV4 ||
-    message.pollCreationMessageV5 ||
-    message.statusAddYours ||
-    message.groupStatusMessage ||
-    message.limitSharingMessage ||
-    message.botTaskMessage ||
-    message.questionMessage ||
-    message.groupStatusMessageV2 ||
-    message.botForwardedMessage ||
-    message.spoilerMessage
+    message?.ephemeralMessage ||
+    message?.viewOnceMessage ||
+    message?.documentWithCaptionMessage ||
+    message?.viewOnceMessageV2 ||
+    message?.viewOnceMessageV2Extension ||
+    message?.editedMessage ||
+    message?.groupMentionedMessage ||
+    message?.botInvokeMessage ||
+    message?.lottieStickerMessage ||
+    message?.eventCoverImage ||
+    message?.statusMentionMessage ||
+    message?.pollCreationOptionImageMessage ||
+    message?.associatedChildMessage ||
+    message?.groupStatusMentionMessage ||
+    message?.pollCreationMessageV4 ||
+    message?.pollCreationMessageV5 ||
+    message?.statusAddYours ||
+    message?.groupStatusMessage ||
+    message?.limitSharingMessage ||
+    message?.botTaskMessage ||
+    message?.questionMessage ||
+    message?.groupStatusMessageV2 ||
+    message?.botForwardedMessage ||
+    message?.spoilerMessage
 );
 
 /**

package/lib/Utils/chat-utils.js

@@ -286,6 +286,22 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
     };
     const mutationMap = {};
     for (const syncd of syncds) {
+      // AunuBaileys (1.0.87, HB-141 + HB-149): snapshot the state
+      // before this patch. The version assignment inside the try
+      // runs BEFORE the patch is decoded, so a patch that failed
+      // (bad content HMAC, missing key, snapshot-MAC mismatch)
+      // still advanced the persisted version past itself — its
+      // mutations were never re-sent by the server, and the LT
+      // hash diverged from the true state permanently: every
+      // later snapshot-MAC check failed while the log claimed the
+      // patch had merely been "skipped". decodeSyncdPatch never
+      // mutates newState in place (the LT-hash generator copies
+      // the index map and returns fresh state), so restoring
+      // these three references in the catch is an exact rollback.
+      const prevVersion = newState.version;
+      const prevHash = newState.hash;
+      const prevIndexValueMap = newState.indexValueMap;
+      const appliedMutations = [];
       try {
         const { version, keyId, snapshotMac } = syncd;
         if (syncd.externalMutations) {
@@ -300,6 +316,11 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
         const decodeResult = await decodeSyncdPatch(syncd, name, newState, getAppStateSyncKey, shouldMutate
             ? mutation => {
                 const index = mutation.syncAction.index?.toString();
+                // (HB-141 + HB-149) record for rollback: a patch
+                // whose snapshot-MAC check fails below has already
+                // delivered its mutations here — they must not
+                // survive being "skipped" either.
+                appliedMutations.push({ index, had: index in mutationMap, prev: mutationMap[index] });
                 mutationMap[index] = mutation;
             }
             : () => { }, true);
@@ -324,6 +345,28 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
         // AunuBaileys: satu patch rusak tidak membunuh seluruh sinkronisasi
         logger?.warn({ err, name, version: syncd.version }, 'skipping undecodable app state patch');
         syncd.mutations = [];
+        // AunuBaileys (1.0.87, HB-141 + HB-149): roll the failed
+        // patch back completely, then stop this batch — later
+        // patches build on this one's state, and letting one of
+        // them advance the persisted version past the hole would
+        // cement the loss. The version stays at the last good
+        // patch, so the next resync re-requests the failed patch
+        // instead of reporting a version that silently skips it;
+        // a transient cause (failed external download, a sync key
+        // that had not arrived yet) now self-heals.
+        newState.version = prevVersion;
+        newState.hash = prevHash;
+        newState.indexValueMap = prevIndexValueMap;
+        for (let i = appliedMutations.length - 1; i >= 0; i--) {
+            const { index, had, prev } = appliedMutations[i];
+            if (had) {
+                mutationMap[index] = prev;
+            }
+            else {
+                delete mutationMap[index];
+            }
+        }
+        break;
       }
     }
     return { state: newState, mutationMap };

package/lib/WAUSync/USyncQuery.js

@@ -110,7 +110,22 @@ export class USyncQuery {
                                 if (errCode === 401 || errCode === 403 || errCode === 405) {
                                     return ['isBlockedByContact', true];
                                 }
-                                throw err;
+                                // AunuBaileys (1.0.87, HB-175): any
+                                // OTHER per-user parser error — the
+                                // protocol node carried an <error>
+                                // child with e.g. a 404 — used to be
+                                // rethrown, aborting the parse of
+                                // the ENTIRE batch: one user's error
+                                // cost every other user's devices /
+                                // contacts, and downstream sends that
+                                // depend on the device list failed
+                                // outright. Treat it the way the
+                                // business parser treats an error
+                                // child: this user simply has no data
+                                // for this protocol (the null is
+                                // dropped by the filter below); the
+                                // rest of the batch continues.
+                                return [protocol, null];
                             }
                         }
                         else {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aunucore/baileys",
   "type": "module",
-  "version": "1.0.86",
+  "version": "1.0.87",
   "description": "AunuBaileys — the self-healing WhatsApp Web API for Node.js. Bad MAC and \"2000 messages into the future\" errors repair themselves, LID and phone-number identities stay in sync, anti-ban is built in, pairing codes are custom — plus 29 experimental features no other Baileys fork ships: invisible watermarks, per-person tag-all cards, side-profile text, ghost mentions and more. ESM, CJS and full TypeScript types.",
   "keywords": [
     "whatsapp",