@prototypevip/baileys 0.0.1 → 0.0.2

package/lib/Socket/chats.js

@@ -1112,6 +1112,7 @@ export const makeChatsSocket = (config) => {
     cleanDirtyBits: cleanDirtyBits,
     addOrEditContact: addOrEditContact,
     removeContact: removeContact,
+    placeholderResendCache: placeholderResendCache,
     addLabel: addLabel,
     addChatLabel: addChatLabel,
     removeChatLabel: removeChatLabel,

package/lib/Socket/messages-send.js

@@ -39,10 +39,11 @@ import {
   buildMergedTcTokenIndexWrite,
   generateCsToken,
   unixTimestampSeconds,
+  DEF_MEDIA_HOST,
 } from "../Utils/index.js";
 import { AssociationType } from "../Types/index.js";
 import { getUrlInfo } from "../Utils/link-preview.js";
-import { makeKeyedMutex } from "../Utils/make-mutex.js";
+import { makeKeyedMutex, makeMutex } from "../Utils/make-mutex.js";
 import {
   getMessageReportingToken,
   shouldIncludeReportingToken,
@@ -105,8 +106,12 @@ export const makeMessagesSocket = (config) => {
     ? new MessageRetryManager(logger, maxMsgRetryCount)
     : null;
   const encryptionMutex = makeKeyedMutex();
+  /** Serializes writes to userDevicesCache across USync refresh and device-notification handling. */
+  const devicesMutex = makeMutex();
   const inFlightTcTokenIssuance = new Set();
   let mediaConn;
+  /** Per-socket media host; updated whenever media_conn is fetched. Defaults to the public WhatsApp host. */
+  let mediaHost = DEF_MEDIA_HOST;
   const issuePrivacyTokens = async (jids, timestamp) => {
     const t = (timestamp ?? unixTimestampSeconds()).toString();
     const result = await query({
@@ -161,6 +166,9 @@ export const makeMessagesSocket = (config) => {
           fetchDate: new Date(),
         };
         logger.debug("fetched media conn");
+        if (node.hosts[0]) {
+          mediaHost = node.hosts[0].hostname;
+        }
         return node;
       })();
     }
@@ -363,18 +371,21 @@ export const makeMessagesSocket = (config) => {
             );
           }
         }
-        if (userDevicesCache.mset) {
-          await userDevicesCache.mset(
-            Object.entries(deviceMap).map(([key, value]) => ({
-              key: key,
-              value: value,
-            })),
-          );
-        } else {
-          for (const key in deviceMap) {
-            if (deviceMap[key]) await userDevicesCache.set(key, deviceMap[key]);
+        await devicesMutex.mutex(async () => {
+          if (userDevicesCache.mset) {
+            await userDevicesCache.mset(
+              Object.entries(deviceMap).map(([key, value]) => ({
+                key: key,
+                value: value,
+              })),
+            );
+          } else {
+            for (const key in deviceMap) {
+              if (deviceMap[key])
+                await userDevicesCache.set(key, deviceMap[key]);
+            }
           }
-        }
+        });
         const userDeviceUpdates = {};
         for (const [userId, devices] of Object.entries(deviceMap)) {
           if (devices && devices.length > 0) {
@@ -1316,6 +1327,8 @@ export const makeMessagesSocket = (config) => {
   const waitForMsgMediaUpdate = bindWaitForEvent(ev, "messages.media-update");
   return {
     ...sock,
+    userDevicesCache: userDevicesCache,
+    devicesMutex: devicesMutex,
     getPrivacyTokens: getPrivacyTokens,
     issuePrivacyTokens: issuePrivacyTokens,
     assertSessions: assertSessions,
@@ -1324,6 +1337,8 @@ export const makeMessagesSocket = (config) => {
     sendReceipts: sendReceipts,
     readMessages: readMessages,
     refreshMediaConn: refreshMediaConn,
+    // Function (not getter) so the spread in chats.js preserves the live closure binding.
+    getMediaHost: () => mediaHost,
     waUploadToServer: waUploadToServer,
     fetchPrivacySettings: fetchPrivacySettings,
     sendPeerMessage: sendPeerMessage,
@@ -1368,7 +1383,7 @@ export const makeMessagesSocket = (config) => {
                   );
                 }
                 content.directPath = media.directPath;
-                content.url = getUrlFromDirectPath(content.directPath);
+                content.url = getUrlFromDirectPath(content.directPath, mediaHost);
                 logger.debug(
                   { directPath: media.directPath, key: result.key },
                   "media update successful",

package/lib/Utils/event-buffer.js

@@ -580,7 +580,12 @@ const consolidateEvents = (data) => {
     Object.keys(data.historySets.messages).length ||
     Object.keys(data.historySets.contacts).length
   ) {
-    map["messaging-history.set"] = data.historySets;
+    map["messaging-history.set"] = {
+      ...data.historySets,
+      chats: Object.values(data.historySets.chats),
+      contacts: Object.values(data.historySets.contacts),
+      messages: Object.values(data.historySets.messages),
+    };
   }
   if (Object.keys(data.chatUpserts).length)
     map["chats.upsert"] = Object.values(data.chatUpserts);

package/lib/Utils/messages.js

@@ -975,15 +975,20 @@ export const generateWAMessageContent = async (message, options) => {
   } else {
     m = await prepareWAMessageMedia(message, options);
   }
-  if (hasOptionalProperty(message, "viewOnce") && !!message.viewOnce) {
+  if (
+    hasOptionalProperty(message, "viewOnce") &&
+    !!message.viewOnce &&
+    !m.viewOnceMessage
+  ) {
     m = { viewOnceMessage: { message: m } };
   }
   if (
     (hasOptionalProperty(message, "mentions") && message.mentions?.length) ||
     (hasOptionalProperty(message, "mentionAll") && message.mentionAll)
   ) {
-    const messageType = Object.keys(m)[0];
-    const key = m[messageType];
+    const target = m.viewOnceMessage ? m.viewOnceMessage.message : m;
+    const messageType = Object.keys(target)[0];
+    const key = target[messageType];
     if (key && "contextInfo" in key) {
       key.contextInfo = key.contextInfo || {};
       if (message.mentions?.length) {
@@ -1431,4 +1436,4 @@ export const assertMediaContent = (content) => {
     });
   }
   return mediaContent;
-};
+};

package/lib/Utils/use-prototype-auth-state.js

@@ -5,13 +5,24 @@ import { LRUCache } from "lru-cache";
 import fs from "fs";
 import path from "path";
 
-export const usePrototypeAuthState = async (config = {}) => {
-  const folder = config.folder || "./auth";
-  if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
+// Reuse ONE Database connection per auth.db file across every session
+// (sub-bot) in this process, instead of opening a brand-new connection
+// per call. Multiple connections hammering the same WAL-mode file is the
+// most likely cause of the occasional "freeze" — a read/write can end up
+// waiting on SQLITE_BUSY behind another connection's lock, which stalls
+// whatever baileys handler triggered it (looks like the bot hung).
+// This also lets us checkpoint + close cleanly on shutdown, so a killed
+// process doesn't leave the WAL file in a state that causes the next
+// boot to stall while SQLite recovers it.
+const dbPool = new Map();
+let exitHandlersRegistered = false;
 
-  const session = config.session || "default";
-  const db = new config.Database(path.join(folder, "auth.db"));
+const getDb = (folder, DatabaseCtor) => {
+  const dbPath = path.resolve(folder, "auth.db");
+  let db = dbPool.get(dbPath);
+  if (db) return db;
 
+  db = new DatabaseCtor(dbPath);
   db.pragma("foreign_keys = ON");
   db.pragma("journal_mode = WAL");
   db.pragma("synchronous = NORMAL");
@@ -19,6 +30,38 @@ export const usePrototypeAuthState = async (config = {}) => {
   db.pragma("cache_size = -128000");
   db.pragma("mmap_size = 524288000");
   db.pragma("busy_timeout = 5000");
+  dbPool.set(dbPath, db);
+
+  if (!exitHandlersRegistered) {
+    exitHandlersRegistered = true;
+    const closeAll = () => {
+      for (const conn of dbPool.values()) {
+        try {
+          conn.pragma("wal_checkpoint(TRUNCATE)");
+          conn.close();
+        } catch {}
+      }
+    };
+    process.once("SIGINT", () => {
+      closeAll();
+      process.exit(0);
+    });
+    process.once("SIGTERM", () => {
+      closeAll();
+      process.exit(0);
+    });
+    process.once("beforeExit", closeAll);
+  }
+
+  return db;
+};
+
+export const usePrototypeAuthState = async (config = {}) => {
+  const folder = config.folder || "./auth";
+  if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
+
+  const session = config.session || "default";
+  const db = getDb(folder, config.Database);
 
   db.prepare(
     "CREATE TABLE IF NOT EXISTS baileys_metadata (name TEXT PRIMARY KEY)",

package/lib/WABinary/generic-utils.js

@@ -145,7 +145,11 @@ const MIXED_NATIVE_FLOW = {
 };
 export const getBizBinaryNode = (message, addBizAttributes) => {
   const bizAttributes = {};
-  const flowMsg = message.interactiveMessage?.nativeFlowMessage;
+  const flowMsg =
+    message.interactiveMessage?.nativeFlowMessage ||
+    message.interactiveMessage?.carouselMessage?.cards?.find(
+      (card) => card?.nativeFlowMessage?.buttons?.length
+    )?.nativeFlowMessage;
   const firstButtonName = flowMsg?.buttons?.[0]?.name;
   const qualityContent = {
     tag: "quality_control",
@@ -199,4 +203,4 @@ export const getBizBinaryNode = (message, addBizAttributes) => {
     };
   }
   return { tag: "biz", attrs: bizAttributes, content: [qualityContent] };
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prototypevip/baileys",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A simple fork of Baileys for WhatsApp automation",
   "main": "lib/index.js",
   "type": "module",