@vanzxy/baileys 1.5.8 → 1.6.0

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

@@ -2456,6 +2456,49 @@ class AIRich extends BaseBuilder {
 		return this;
 	}
 
+	// Vanz@Add 25-08-26 --- ported from temen's MessageBuilderV4.7 (hasId/getIds/peek/delete).
+	// That fork tracked every block in a unified `_nodes` array so query/delete-by-id was free;
+	// this fork instead tracks blocks in the `_blocks` Map (id -> {subItems, secItems}, populated
+	// by the constructor's Proxy on every add*/set* call that passes {id}) but never exposed a way
+	// to query or undo one after the fact — you could insertAt an id but never inspect, check, or
+	// remove it. These 4 read/delete that same Map, so no changes to the Proxy itself were needed.
+
+	/** Check whether a block id was registered by an earlier `add*()`/`set*()` call passing `{id}`. */
+	hasId(id) {
+		return typeof id === 'string' && this._blocks.has(id);
+	}
+
+	/** List every block id registered so far, in no particular order. */
+	getIds() {
+		return [...this._blocks.keys()];
+	}
+
+	/** Inspect a registered block without modifying it. Returns `null` if `id` isn't registered. */
+	peek(id) {
+		const block = this._blocks.get(id);
+		if (!block) return null;
+
+		return { id, sections: [...block.secItems], submessages: [...block.subItems] };
+	}
+
+	/** Remove a previously-added block (by the `id` passed to its `add*()`/`set*()` call) from the message. Throws if `id` isn't registered. */
+	delete(id) {
+		const block = this._blocks.get(id);
+		if (!block) throw new Error(`delete(id): no block registered with id "${id}"`);
+
+		for (const item of block.subItems) {
+			const idx = this._submessages.indexOf(item);
+			if (idx !== -1) this._submessages.splice(idx, 1);
+		}
+		for (const item of block.secItems) {
+			const idx = this._sections.indexOf(item);
+			if (idx !== -1) this._sections.splice(idx, 1);
+		}
+
+		this._blocks.delete(id);
+		return this;
+	}
+
 	/** Add a small metadata-style text line (`GenAIMetadataTextPrimitive`) — same visual style as the auto-appended footer/`addTip()`'s callout, but insertable anywhere and without `addTip()`'s icon prefix. */
 	addMetadata(text) {
 		if (typeof text !== 'string' || !text) throw new TypeError('addMetadata(text) requires a non-empty string');
@@ -2496,11 +2539,14 @@ class AIRich extends BaseBuilder {
 		return this;
 	}
 
-	// Vanz@Add 22-08-26 (v4.7) --- addHeading/addImageCard/addWidget/addFooterAction: 4 primitives
+	// Vanz@Add 22-08-26 (v4.7) --- addHeading/addWidget/addFooterAction: 3 primitives
 	// reverse-engineered from captured Meta-AI-in-WhatsApp traffic that this project's own crm/snip
 	// tooling (see rich-message-utils.js) dumps for study. Not in any public Baileys schema, so
 	// unknown enum values (kind/state on addWidget's ctas) are passed through as observed rather
 	// than guessed at, and documented as experimental below.
+	// Vanz@Fix 25-08-26 --- removed addImageCard(): its GenAIImagePrimitive/preview_image+full_image
+	// shape was mis-reverse-engineered (not a real WA schema) and crashed the client renderer on
+	// arrival. addImage() already covers static image cards correctly — use that instead.
 
 	/** Add a large heading-style text block (`FOATextPrimitive`) — visually distinct from `addText()`'s regular paragraph text. */
 	addHeading(text) {
@@ -2523,39 +2569,6 @@ class AIRich extends BaseBuilder {
 		return this;
 	}
 
-	/**
-	 * Add a "ready" static image card (`GenAIImagePrimitive`: preview + full-res, no generating/status
-	 * state) — distinct from `addImage()`'s AI-generation-style `GenAIImaginePrimitive`.
-	 * @param {string|Buffer} previewUrl Preview/thumbnail image.
-	 * @param {string|Buffer} [fullUrl] Full-resolution image; defaults to `previewUrl`.
-	 */
-	addImageCard(previewUrl, fullUrl = previewUrl, { resolveUrl = false } = {}) {
-		if (!(typeof previewUrl === 'string' || Buffer.isBuffer(previewUrl))) {
-			throw new TypeError('addImageCard(previewUrl) requires a string url or buffer');
-		}
-
-		const preview = Toolkit.resolveMedia(this.#client, previewUrl, 'image', { resolveUrl });
-		const full = fullUrl === previewUrl ? preview : Toolkit.resolveMedia(this.#client, fullUrl, 'image', { resolveUrl });
-
-		this._submessages.push({
-			messageType: 1,
-			gridImageMetadata: {
-				gridImageUrl: { imagePreviewUrl: preview },
-				imageUrls: [{ imagePreviewUrl: preview, imageHighResUrl: full, sourceUrl: full }],
-			},
-		});
-
-		this._sections.push(
-			AIRich.newLayout('Single', {
-				preview_image: { url: preview, mime_type: 'image/jpeg', __typename: 'GenAIMediaItem' },
-				full_image: { url: full, mime_type: 'image/jpeg', __typename: 'GenAIMediaItem' },
-				__typename: 'GenAIImagePrimitive',
-			})
-		);
-
-		return this;
-	}
-
 	/**
 	 * Add a "3P extension" widget card (`GenAI3PExtWidgetPrimitive`) — a small panel with a title and
 	 * a row of tappable CTA chips. Per captured traffic these CTAs call back into a tool (`tool_call_id`)

package/lib/Utils/MessageBuilder_d.ts

@@ -178,10 +178,12 @@ export class AIRich extends BaseBuilder {
 	refreshResponseId(): this;
 	setBotResponseId(id: string): this;
 	refreshBotResponseId(): this;
+	hasId(id: string): boolean;
+	getIds(): string[];
+	peek(id: string): { id: string; sections: any[]; submessages: any[] } | null;
+	delete(id: string): this;
 	/** FOATextPrimitive — large heading text, distinct from addText()'s paragraph text. */
 	addHeading(text: string): this;
-	/** GenAIImagePrimitive — "ready" static image (preview + full-res), distinct from addImage()'s generation-style card. */
-	addImageCard(previewUrl: string | Buffer, fullUrl?: string | Buffer, options?: { resolveUrl?: boolean }): this;
 	/** GenAI3PExtWidgetPrimitive — experimental, reverse-engineered; see JSDoc in the .js file for caveats. */
 	addWidget(data: Record<string, any> | Record<string, any>[], options?: { layout?: 'Single' | 'HScroll' | 'ActionRow' | string }): this;
 	/** GenAIFooterActionPrimitive — footer action link chips (e.g. "Join our Group"). */

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.6.0",
   "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",