my-baileys 1.0.2 → 1.0.3

package/README.md

@@ -594,6 +594,34 @@ await sock.forwardMessage(jid, originalMsg);
 await sock.broadcastMessage(jidList, { text: 'Announcement' });
 ```
 
+### `sendHtml()` — experimental, read this first
+
+```javascript
+await sock.sendHtml(jid, '<b>Hello</b> from my bot');
+```
+
+This mirrors WhatsApp's own internal "Meta AI" chat message shape
+(`botForwardedMessage` → `richResponseMessage`, internally named `GenAIUnifiedResponse` /
+`FOAHtmlPrimitiveDemoDONOTUSE` in WhatsApp's own protocol — that `DONOTUSE` suffix is Meta's own
+naming for an experimental feature flag, not a warning from us). It is **not** a documented,
+stable public message type, so:
+
+- WhatsApp's client may render it inline, show a "tap to view"/download prompt, or (if the
+  feature gets pulled server-side) not render it at all — behavior isn't guaranteed and can
+  change without notice, since your bot isn't the actual verified Meta AI account this format
+  was designed for.
+- **Bug fixed:** earlier versions of this method unconditionally marked every message
+  `contextInfo: { isForwarded: true, forwardOrigin: 4 /* META_AI */ }` — literally claiming
+  every message was forwarded from Meta AI, which is almost certainly why some people saw it
+  require an extra tap/download before showing up (a non-verified sender claiming Meta AI
+  origin is exactly what you'd expect WhatsApp to treat cautiously). It now sends as a plain,
+  non-forwarded message by default; pass `{ contextInfo: {...} }` yourself if you have a
+  specific reason to set forwarding metadata.
+
+If you need something guaranteed to render reliably, prefer a documented content type
+(`sendButtonsMessage`, `sendListMessage`, a plain `{ text }`, etc.) — `sendHtml` is here for
+experimentation, not as a recommended primary way to send rich content.
+
 If you have `antiban: true` (or a preset) set, these all go through it too — `forwardMessage`,
 `sendActionPoll`, and `broadcastMessage` call `sock.sendMessage()` internally, same as calling
 it yourself. (`sendJsonMessage`/`sendCarouselMessage` use the lower-level `relayMessage()` and
@@ -920,8 +948,17 @@ store.bind(client.ev);
 client.ev.on('contacts.upsert', () => {
   console.log('New contact: ' + Object.values(store.contacts()));
 });
+
+// persist the whole store to disk, and restore it on the next run
+setInterval(() => store.writeToFile('./baileys-store.json'), 10_000);
+store.readFromFile('./baileys-store.json'); // call before store.bind() to load prior state
 ```
 
+Two real bugs in the store's `KeyedDB` were found and fixed while adding `writeToFile`/
+`readFromFile`: `chats.get(jid)` / `.update(jid, ...)` / `.deleteById(jid)` didn't actually work
+before this fix (see [LITERACY.md → Changelog vs upstream](LITERACY.md#changelog-vs-upstream)
+for the full story), so if you were relying on those specifically, they now behave as expected.
+
 ---
 
 ## Sending messages

package/lib/Socket/message-builder.js

@@ -18,13 +18,6 @@ export const makeMessageBuilderSocket = (sock) => {
         const msg = generateWAMessageFromContent(jid, content, {});
         return relayMessage(jid, msg.message, { messageId: msg.key.id, ...options });
     };
-
-    /**
-     * Sends an HTML GenAI primitive rich response message.
-     * html: string template/raw HTML markup to be rendered.
-     * (Added from xbailsync@1.0.7 — a plain, explicit send, nothing hidden:
-     * only runs when you call it, same as every other method here.)
-     */
     const sendHtml = async (jid, html = '', options = {}) => {
         const payloadData = Buffer.from(
             JSON.stringify({
@@ -54,10 +47,7 @@ export const makeMessageBuilderSocket = (sock) => {
                         unifiedResponse: {
                             data: payloadData
                         },
-                        contextInfo: {
-                            isForwarded: true,
-                            forwardOrigin: 4
-                        }
+                        ...(options.contextInfo ? { contextInfo: options.contextInfo } : {})
                     }
                 }
             }

package/lib/Store/keyed-db.js

@@ -23,7 +23,20 @@ export default class KeyedDB {
         this._dict[id] = entry;
         let inserted = false;
         for (let i = 0; i < this._array.length; i++) {
-            const cmp = this._compare(this._idGetter(this._array[i]), id);
+            // BUG FIX (found while adding writeToFile/readFromFile — see
+            // make-in-memory-store.js changelog note): this used to compare
+            // this._idGetter(this._array[i]) against `id` — i.e. it fed the
+            // ID-getter's output into `_compare` on both sides. That only
+            // works if idGetter ALSO doubles as a sort-priority key (which
+            // it did for the old `waChatKey`, at the cost of breaking
+            // `get()`/`update()`/`deleteById()`, since those take a *plain*
+            // id, not a composite sort key, and index into `_dict` by
+            // whatever `idGetter` actually returns). Comparing the full
+            // entries directly instead — matching @vansnowi/baileys@1.5.9's
+            // implementation — lets idGetter go back to being just "the
+            // plain unique id", with `compare` doing its own real job of
+            // ordering two full entries.
+            const cmp = this._compare(entry, this._array[i]);
             if (cmp < 0) {
                 this._array.splice(i, 0, entry);
                 inserted = true;

package/lib/Store/make-in-memory-store.js

@@ -6,26 +6,55 @@ import * as WABinary_1 from "../WABinary/index.js";
 import makeOrderedDictionary from "./make-ordered-dictionary.js";
 import { ObjectRepository } from "./object-repository.js";
 import KeyedDB from "./keyed-db.js";
-
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+// BUG FIX (see keyed-db.js's insert() for the full story): `key` used to
+// return a composite string (pin flag + archive flag + hex timestamp + id)
+// that doubled as BOTH the KeyedDB dict-lookup id AND the sort-priority
+// encoding. That broke `chats.get(jid)` / `.update(jid, ...)` /
+// `.deleteById(jid)` for every caller passing a plain JID (which is every
+// caller in this codebase) — `_dict` was keyed by the composite string, so a
+// plain-JID lookup never matched. `key` is now just the plain chat id;
+// `compare` does the actual pin/archived/most-recent-first ordering
+// directly on two full chat entries, preserving the exact same sort order
+// as before (pinned first, then non-archived first, then newest
+// conversationTimestamp first, id as the final tie-break to match the old
+// descending-string-compare behavior).
 const waChatKey = (pin) => ({
-    key: (c) =>
-        (pin ? (c.pinned ? "1" : "0") : "") +
-        (c.archived ? "0" : "1") +
-        (c.conversationTimestamp
-            ? c.conversationTimestamp.toString(16).padStart(8, "0")
-            : "") +
-        c.id,
-    compare: (k1, k2) => k2.localeCompare(k1)
+    key: (c) => c.id,
+    compare: (c1, c2) => {
+        if (pin) {
+            const p1 = c1.pinned ? 1 : 0;
+            const p2 = c2.pinned ? 1 : 0;
+            if (p1 !== p2) return p2 - p1;
+        }
+        const a1 = c1.archived ? 0 : 1;
+        const a2 = c2.archived ? 0 : 1;
+        if (a1 !== a2) return a2 - a1;
+        const t1 = c1.conversationTimestamp ? Number(c1.conversationTimestamp) : 0;
+        const t2 = c2.conversationTimestamp ? Number(c2.conversationTimestamp) : 0;
+        if (t1 !== t2) return t2 - t1;
+        return (c2.id || "").localeCompare(c1.id || "");
+    }
 });
 
 export const waMessageID = (m) => m.key.id || "";
 
+// BUG FIX, same root cause as waChatKey above: `compare` used to receive
+// the two entries' composite `key(...)` STRING outputs (via keyed-db.js's
+// old buggy insert()), which is why plain string `.localeCompare` worked
+// there previously — but only by coincidence, since `key` here (unlike
+// chats') already IS the plain lookup id, not a separate sort-priority
+// encoding. Updated to a proper entry-to-entry comparator (computing the
+// same composite key from each full entry) so it keeps working correctly
+// now that keyed-db.js's insert() passes full entries instead of
+// pre-computed key strings.
 export const waLabelAssociationKey = {
     key: (la) =>
         la.type === LabelAssociationType.Chat
             ? la.chatId + la.labelId
             : la.chatId + la.messageId + la.labelId,
-    compare: (k1, k2) => k2.localeCompare(k1)
+    compare: (a, b) => waLabelAssociationKey.key(b).localeCompare(waLabelAssociationKey.key(a))
 };
 
 const makeMessagesDictionary = () => makeOrderedDictionary(waMessageID);
@@ -110,7 +139,11 @@ export default function makeInMemoryStore(config) {
 
         ev.on("labels.association", ({ type, association }) => {
             if (type === "add") labelAssociations.upsert(association);
-            if (type === "remove") labelAssociations.delete(association);
+            // BUG FIX: was `labelAssociations.delete(association)` — KeyedDB
+            // has no `.delete()` method (only `.deleteById(id)`), so this
+            // threw `TypeError: labelAssociations.delete is not a function`
+            // every time a label association was actually removed.
+            if (type === "remove") labelAssociations.deleteById(labelAssociationKey.key(association));
         });
 
         ev.on("presence.update", ({ id, presences: update }) => {
@@ -181,6 +214,26 @@ export default function makeInMemoryStore(config) {
     const loadMessage = async (jid, id) => {
         return messages[jid]?.get(id)
     }
+    // Added from @vansnowi/baileys@1.5.9 — the two persistence entry points
+    // that were missing here even though toJSON()/fromJSON() (this fork's
+    // own, more careful versions — see fromJSON above, which reconstructs
+    // proper WebMessageInfo instances instead of leaving raw parsed JSON)
+    // already existed. Uses this fork's own shared BufferJSON.replacer/
+    // reviver (Utils/generics.js, already used by make-cache-manager-store.js)
+    // rather than duplicating a private copy, so Buffers inside the store
+    // (media keys, etc.) survive a save/load round-trip intact.
+    const writeToFile = (path) => {
+        const data = JSON.stringify(toJSON(), Utils_1.BufferJSON.replacer);
+        writeFileSync(path, data);
+    };
+    const readFromFile = (path) => {
+        if (existsSync(path)) {
+            logger?.debug?.({ path }, "reading store from file");
+            const jsonStr = readFileSync(path, { encoding: "utf-8" });
+            const json = JSON.parse(jsonStr, Utils_1.BufferJSON.reviver);
+            fromJSON(json);
+        }
+    };
     return {
         chats,
         contacts,
@@ -193,6 +246,8 @@ export default function makeInMemoryStore(config) {
         bind,
         toJSON,
         fromJSON,
+        writeToFile,
+        readFromFile,
         loadMessage
     };
 }

package/lib/Utils/messages.js

@@ -26,11 +26,6 @@ const MessageTypeProto = {
     sticker: WAProto.Message.StickerMessage,
     document: WAProto.Message.DocumentMessage
 };
-// Added from baileys@6.2.7: lets generateWAMessageFromContent() accept a raw
-// proto message-type key directly (e.g. `{ conversation: 'hi' }`), bypassing
-// the normal content-type-detection chain below — see the final `else` in
-// generateWAMessageFromContent(). Falls back to prepareWAMessageMedia() as
-// before for anything not in this list.
 const RAW_PROTO_MESSAGE_KEYS = [
     'conversation', 'senderKeyDistributionMessage', 'imageMessage', 'contactMessage', 'locationMessage',
     'extendedTextMessage', 'documentMessage', 'audioMessage', 'videoMessage', 'call', 'chat', 'protocolMessage',
@@ -887,8 +882,6 @@ export const generateWAMessageContent = async (message, options) => {
         };
     }
     else if (hasNonNullishProperty(message, 'stickerPacks')) {
-        // Added from baileys@6.2.7: send a whole sticker pack (multiple
-        // .webp stickers + a tray icon, zipped) as one stickerPackMessage.
         const pack = message.stickerPacks;
         const rawStickers = Array.isArray(pack.stickers) ? pack.stickers : [];
         if (rawStickers.length === 0) {
@@ -964,11 +957,6 @@ export const generateWAMessageContent = async (message, options) => {
         };
     }
     else if (hasNonNullishProperty(message, 'sticker') && (message.pack || message.author || message.isPrivate || message.premium || message.animated)) {
-        // Added from baileys@6.2.7: `{ sticker, pack/author/isPrivate/animated/premium }`
-        // auto-converts the given image/video into a proper sticker (via makeSticker)
-        // instead of requiring an already-built .webp. Plain `{ sticker: <webp> }`
-        // with none of those extra options still falls through to the normal
-        // prepareWAMessageMedia path below, unchanged.
         const rawBuffer = await resolveStickerBuffer(message.sticker, options.options);
         const finalWebp = await makeSticker(rawBuffer, {
             pack: message.pack || '',
@@ -991,8 +979,6 @@ export const generateWAMessageContent = async (message, options) => {
     else {
         const rawProtoKey = RAW_PROTO_MESSAGE_KEYS.find(k => hasNonNullishProperty(message, k));
         if (rawProtoKey) {
-            // Added from baileys@6.2.7: pass a raw proto message-type key straight
-            // through, bypassing content-type detection entirely.
             const built = proto.Message.fromObject({ [rawProtoKey]: message[rawProtoKey] });
             m = { [rawProtoKey]: built[rawProtoKey] };
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "my-baileys",
   "type": "module",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A WebSockets library for interacting with WhatsApp Web — XYCoolcraft fork of Baileys",
   "keywords": [
     "xycoolcraft",