@vanzxy/baileys 1.5.7 → 1.5.9

package/lib/Socket/chats.js

@@ -712,35 +712,82 @@ export const makeChatsSocket = (config) => {
     // has a courtesy retry via blockedCollections + the creds.update listener below — the key
     // arrives async after connect (APP_STATE_SYNC_KEY_SHARE), so calling e.g. updateProfileName()
     // right after connection.update === 'open' would reliably fail on a fresh/early connection.
-    // Now appPatch() waits (bounded, 10s default) for the same creds.update event before giving up,
+    // Now appPatch() waits (bounded, 20s default) for the same creds.update event before giving up,
     // instead of failing hard on what's usually just a timing race.
-    const waitForAppStateKeyId = (timeoutMs = 10_000) => {
+    //
+    // Vanz@Fix 25-08-26 --- the event-only wait had a blind spot: if `creds.update` never actually
+    // reaches this listener (swallowed/filtered by a wrapper around `ev`, a custom auth-state
+    // adapter that patches `authState.creds` directly without re-emitting the event, etc.) this
+    // would sit for the full timeout and fail even though `authState.creds.myAppStateKeyId` was
+    // genuinely set the whole time. Added a belt-and-suspenders poll of the creds object itself
+    // alongside the event listener — whichever one notices the key first wins, and both are torn
+    // down together so there's no leaked timer/listener either way.
+    const waitForAppStateKeyId = (timeoutMs = 20_000, pollMs = 500) => {
         if (authState.creds.myAppStateKeyId) {
             return Promise.resolve(authState.creds.myAppStateKeyId);
         }
         return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
+            let settled = false;
+            const cleanup = () => {
+                settled = true;
+                clearTimeout(timeout);
+                clearInterval(poller);
                 ev.off('creds.update', onUpdate);
+            };
+            const timeout = setTimeout(() => {
+                if (settled) return;
+                cleanup();
+                logger.warn(
+                    { hasMyAppStateKeyId: !!authState.creds.myAppStateKeyId, registered: authState.creds.registered },
+                    'waitForAppStateKeyId timed out — APP_STATE_SYNC_KEY_SHARE was never received/applied for this session'
+                );
                 reject(new Boom('App state key not present!', { statusCode: 400 }));
             }, timeoutMs);
+            const poller = setInterval(() => {
+                if (settled || !authState.creds.myAppStateKeyId) return;
+                const id = authState.creds.myAppStateKeyId;
+                cleanup();
+                resolve(id);
+            }, pollMs);
             const onUpdate = ({ myAppStateKeyId }) => {
-                if (!myAppStateKeyId) return;
-                clearTimeout(timeout);
-                ev.off('creds.update', onUpdate);
+                if (settled || !myAppStateKeyId) return;
+                cleanup();
                 resolve(myAppStateKeyId);
             };
             ev.on('creds.update', onUpdate);
         });
     };
+    // Vanz@Fix (perf) --- appPatch() unconditionally round-tripped resyncAppState() to the WA
+    // server on EVERY single call, even for back-to-back patches (e.g. updateProfileName then
+    // immediately archiving/muting a chat) where the local version was already fresh from the
+    // resync a few hundred ms ago. That round trip is the main source of the multi-second delay
+    // people notice on things like "ganti nama". Cache the last-synced timestamp per collection
+    // name and skip the resync if it happened within RESYNC_TTL_MS — WA's own client does the
+    // same kind of short-lived debouncing. Set RESYNC_TTL_MS to 0 to restore the old always-resync
+    // behavior if this ever causes a stale-version conflict in practice.
+    const RESYNC_TTL_MS = 4000;
+    const lastResyncAt = new Map();
     const appPatch = async (patchCreate) => {
         const name = patchCreate.type;
+        const t0 = Date.now();
         const myAppStateKeyId = await waitForAppStateKeyId();
+        const tKey = Date.now();
         let initial;
         let encodeResult;
         await appStatePatchMutex.mutex(async () => {
             await authState.keys.transaction(async () => {
                 logger.debug({ patch: patchCreate }, 'applying app patch');
-                await resyncAppState([name], false);
+                const lastSync = lastResyncAt.get(name) ?? 0;
+                const freshEnough = RESYNC_TTL_MS > 0 && Date.now() - lastSync < RESYNC_TTL_MS;
+                if (!freshEnough) {
+                    await resyncAppState([name], false);
+                    lastResyncAt.set(name, Date.now());
+                }
+                const tResync = Date.now();
+                logger.debug(
+                    { patch: name, waitedForKeyMs: tKey - t0, resyncMs: freshEnough ? 0 : tResync - tKey, skippedResync: freshEnough },
+                    'appPatch timing'
+                );
                 const { [name]: currentSyncVersion } = await authState.keys.get('app-state-sync-version', [name]);
                 initial = currentSyncVersion ? ensureLTHashStateVersion(currentSyncVersion) : newLTHashState();
                 encodeResult = await encodeSyncdPatch(patchCreate, myAppStateKeyId, initial, getAppStateSyncKey);
@@ -1068,6 +1115,11 @@ export const makeChatsSocket = (config) => {
             if (syncState === SyncState.Syncing) {
                 // All collections will be synced, so clear any blocked ones
                 blockedCollections.clear();
+                // Vanz@Fix (perf cache invalidation) --- a full sync is about to run for every
+                // collection, so any per-collection "recently resynced" cache from appPatch()
+                // is now stale by definition; drop it so the next appPatch() call resyncs fresh
+                // instead of trusting a pre-full-sync timestamp.
+                lastResyncAt.clear();
                 logger.info('Doing app state sync');
                 await resyncAppState(ALL_WA_PATCH_NAMES, true);
                 // Sync is complete, go online and flush everything
@@ -1129,6 +1181,9 @@ export const makeChatsSocket = (config) => {
     ev.on('connection.update', ({ connection, receivedPendingNotifications }) => {
         if (connection === 'close') {
             blockedCollections.clear();
+            // Vanz@Fix (perf cache invalidation) --- connection dropped, so any "recently
+            // resynced" timestamps are no longer trustworthy once we reconnect.
+            lastResyncAt.clear();
             clearTimeout(historySyncPausedTimeout);
             historySyncPausedTimeout = undefined;
         }

package/lib/Utils/MessageBuilder.js

@@ -336,6 +336,14 @@ class Toolkit {
 
 		const isWAUrl = (str) => /^https?:\/\/[^/]*\.whatsapp\.net\//i.test(str);
 
+		// Vanz@Fix (crash guard) --- keep the original raw url around so that if the
+		// resolveUrl=true upload-to-'@newsletter' round trip (Toolkit.toUrl -> prepareWAMessageMedia)
+		// throws/rejects (blocked account, network hiccup, WA server refusal, etc.), we can
+		// gracefully fall back to the raw url instead of letting the rejection bubble up
+		// unhandled through waitAllPromises() and take the whole process down. Only applies
+		// when the input was actually a url string; buffers/base64 have no such fallback.
+		const rawUrlFallback = typeof media === 'string' && isUrl(media) ? media : undefined;
+
 		if (Array.isArray(media)) {
 			return Promise.all(
 				media.map((item) =>
@@ -395,7 +403,16 @@ class Toolkit {
 		// same `Toolkit.toUrl(_client, media, mediaType)` call (dead branching left over from an
 		// earlier version that must have treated buffer vs non-buffer input differently). Collapsed
 		// to a single return; `originalIsBuffer` is now unused and removed below.
-		return Toolkit.toUrl(_client, media, mediaType);
+		//
+		// Vanz@Fix (crash guard) --- toUrl() uploads to WA's media server under a spoofed
+		// '@newsletter' jid; if that upload fails for any reason, fall back to the raw url
+		// (when we have one) instead of letting the exception propagate and crash the caller.
+		try {
+			return await Toolkit.toUrl(_client, media, mediaType);
+		} catch (err) {
+			if (rawUrlFallback) return rawUrlFallback;
+			throw err;
+		}
 	}
 
 	/** Read an mp4 buffer's duration (seconds) straight from its moov atom, no ffprobe needed. */

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, readdir, stat, unlink, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { proto } from '../../WAProto/index.js';
 import { initAuthCreds } from './auth-utils.js';
@@ -18,6 +18,49 @@ const getFileLock = (path) => {
     }
     return mutex;
 };
+// Vanz@Fix 25-08-26 (ENOSPC guard) --- useMultiFileAuthState writes one small file PER key id
+// (session-*, sender-key-*, sender-key-memory-*, pre-key-*, app-state-sync-key-*, ...) and never
+// prunes any of them on its own. Over months of uptime — especially in busy groups, where a
+// sender-key-memory file is created per (group, participant) pair — this silently accumulates into
+// hundreds of thousands of tiny files. That can hit the filesystem's inode/file-count ceiling and
+// start throwing ENOSPC on writes long before disk *space* usage looks anywhere near full (a
+// classic symptom: panel shows plenty of free MiB/GiB, but writes still fail with ENOSPC). When
+// that happens mid-session, auth writes (including the app-state-sync key from the "App state key
+// not present!" issue) fail silently and never actually persist.
+//
+// `sender-key-memory-*` entries are pure dedup/anti-replay cache — safe to delete anytime; Baileys
+// regenerates them on demand with zero functional loss (worst case: one redundant re-decrypt). They
+// also tend to be the single biggest contributor to file count in active groups, so they're the
+// safest and highest-impact thing to prune automatically. Everything else (creds, real sessions,
+// pre-keys, app-state-sync-keys) is left completely untouched — this never touches those.
+export const pruneStaleAuthFiles = async (folder, { maxAgeDays = 14, categories = ['sender-key-memory'], dryRun = false } = {}) => {
+    let entries;
+    try {
+        entries = await readdir(folder);
+    }
+    catch {
+        return { scanned: 0, removed: 0 };
+    }
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    let scanned = 0;
+    let removed = 0;
+    await Promise.all(entries.map(async (name) => {
+        if (!categories.some((cat) => name.startsWith(`${cat}-`) && name.endsWith('.json'))) return;
+        scanned++;
+        const filePath = join(folder, name);
+        try {
+            const info = await stat(filePath);
+            if (info.mtimeMs < cutoff) {
+                if (!dryRun) await unlink(filePath).catch(() => { });
+                removed++;
+            }
+        }
+        catch {
+            // file vanished between readdir and stat — fine, nothing to prune
+        }
+    }));
+    return { scanned, removed };
+};
 /**
  * stores the full authentication state in a single folder.
  * Far more efficient than singlefileauthstate
@@ -83,6 +126,9 @@ export const useMultiFileAuthState = async (folder) => {
     else {
         await mkdir(folder, { recursive: true });
     }
+    // Vanz@Fix 25-08-26 (ENOSPC guard) --- best-effort prune on every startup. Failures here must
+    // never block auth from loading, so this is intentionally fire-and-forget with its own catch.
+    pruneStaleAuthFiles(folder).catch(() => { });
     const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
     const creds = (await readData('creds.json')) || initAuthCreds();
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanzxy/baileys",
-  "version": "1.5.7",
+  "version": "1.5.9",
   "description": "Enhanced Baileys fork by Vanzxy — based on @itsliaaa/baileys + @whiskeysockets/baileys with fixes for audio group status and clean media without newsletter button.",
   "type": "module",
   "module": "./lib/index.js",