@vanzxy/baileys 1.5.8 → 1.5.9

package/lib/Socket/chats.js

@@ -712,21 +712,46 @@ 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);

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.8",
+  "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",