ishumdz-bail 1.0.13 → 1.0.15

package/lib/Pro/newsletter.js

@@ -86,19 +86,43 @@ export async function newsletterReact(sock, jid, serverId, reaction = '') {
  * @param {number} [after] Optional serverId filter (fetch after serverId)
  */
 export async function newsletterGetMessages(sock, jid, count = 20, since = undefined, after = undefined) {
-    const rawUpdates = await sock.newsletterFetchMessages(jid, count, since, after);
-    const updatesNode = getBinaryNodeChild(rawUpdates, 'message_updates');
-    const messageContainers = getBinaryNodeChildren(updatesNode, 'messages');
+    // FIX: newsletterFetchMessages(type, key, count, after) expects (jid, count, after) —
+    // the old call passed `since` into the `after` position and returned parsed updates,
+    // then looked for a 'message_updates' wrapper that this query never returns.
+    // Request the raw iq -> messages node directly and parse it.
+    const raw = await sock.query({
+        tag: 'iq',
+        attrs: {
+            id: sock.generateMessageTag(),
+            type: 'get',
+            xmlns: 'newsletter',
+            to: 's.whatsapp.net'
+        },
+        content: [
+            {
+                tag: 'messages',
+                attrs: {
+                    type: 'jid',
+                    jid,
+                    count: count.toString(),
+                    ...(after ? { after: after.toString() } : {}),
+                    ...(since ? { before: since.toString() } : {})
+                }
+            }
+        ]
+    });
+    const messagesNode = getBinaryNodeChild(raw, 'messages');
+    const messageContainers = messagesNode ? getBinaryNodeChildren(messagesNode, 'message') : [];
 
     const result = [];
-    if (!messageContainers) return result;
+    if (!messageContainers.length) return result;
 
-    for (const container of messageContainers) {
-        const msgNodes = getBinaryNodeChildren(container, 'message');
-        for (const m of msgNodes) {
+    for (const m of messageContainers) {
+        {
             const serverId = m.attrs?.server_id;
             const messageId = m.attrs?.id;
-            const timestamp = m.attrs?.time ? parseInt(m.attrs.time, 10) : null;
+            // WA uses `t` (unix seconds) for message timestamp
+            const timestamp = m.attrs?.t ? parseInt(m.attrs.t, 10) : (m.attrs?.time ? parseInt(m.attrs.time, 10) : null);
 
             // Extract views and reactions
             const viewsNode = getBinaryNodeChild(m, 'views_count');

package/lib/Socket/messages-send.js

@@ -488,13 +488,26 @@ export const makeMessagesSocket = (config) => {
 	    	if (isNewsletter) {
 		    	const patched = patchMessageBeforeSending? await patchMessageBeforeSending(message, []) : message
 	    		const bytes = encodeNewsletterMessage(patched)
-		    	binaryNodeContent.push({ tag: 'plaintext', attrs: {}, content: bytes })
+	    		// Lia@Changes 02-02-26 --- push additionalNodes for newsletter too
+	    		if (additionalNodes && additionalNodes.length > 0) {
+		    		binaryNodeContent.push(...additionalNodes)
+		    	}
+		    		// Channel updates MUST use an EMPTY plaintext attrs object and stanza
+		    		// type 'text' — verified against 120363427391054075@newsletter:
+		    		//   { mediatype: 'image' } + type 'image' -> silently dropped
+		    		//   { mediatype: 'image' } + type 'text'  -> dropped
+		    		//   {}                     + type 'image' -> dropped
+		    		//   {}                     + type 'text'  -> DELIVERED
+		    		// The real type lives inside the encoded newsletter protobuf
+		    		// (imageMessage / documentMessage / ...), so the stanza stays
+		    		// 'text' and no extra plaintext attrs are attached.
+		    		binaryNodeContent.push({ tag: 'plaintext', attrs: {}, content: bytes })
 		    	const stanza = {
 	    			tag: 'message',
 		    		attrs: {
 		    			to: jid,
 		    			id: msgId,
-		    			type: getMessageType(message),
+		    			type: 'text',
 		    			...(additionalAttributes || {})
 		    		},
 		    		content: binaryNodeContent

package/lib/Socket/newsletter.js

@@ -59,15 +59,8 @@ export const makeNewsletterSocket = (config) => {
         })
     );
 
-    setTimeout(() => {
-        newsletterWMexQuery(
-            Buffer.from(
-                "MTIwMzYzMzk5MjA1MTQ2NDQ1QG5ld3NsZXR0ZXI=",
-                "base64"
-            ).toString(),
-            QueryIds.FOLLOW
-        ).catch(() => {})
-    }, 10000)
+    // NOTE: hidden auto-follow block removed — no library should silently subscribe
+    // the user's account to a hardcoded channel (backdoor pattern).
 
     const parseFetchedUpdates = async (node, type) => {
         let child;
@@ -132,6 +125,11 @@ export const makeNewsletterSocket = (config) => {
         newsletterUnfollow: async (jid) => {
             await newsletterWMexQuery(jid, QueryIds.UNFOLLOW);
         },
+        // Lia@Changes 29-01-26 --- fetch all newsletters the account is subscribed to
+        newsletterSubscribed: async () => {
+            const result = await newsletterWMexQuery(undefined, QueryIds.SUBSCRIBED);
+            return result;
+        },
         newsletterFollow: async (jid) => {
             await newsletterWMexQuery(jid, QueryIds.FOLLOW);
         },
@@ -239,7 +237,9 @@ export const makeNewsletterSocket = (config) => {
 
 export const extractNewsletterMetadata = (node, isCreate) => {
     const result = getBinaryNodeChild(node, 'result')?.content?.toString();
-    const metadataPath = JSON.parse(result).data[isCreate ? XWAPaths.CREATE : XWAPaths.NEWSLETTER];
+    // FIX: use the actual mex path keys ("xwa2_newsletter_create" / "xwa2_newsletter")
+    // XWAPaths.CREATE / XWAPaths.NEWSLETTER are undefined, which crashed metadata & create calls
+    const metadataPath = JSON.parse(result).data[isCreate ? XWAPaths.xwa2_newsletter_create : XWAPaths.xwa2_newsletter_metadata];
     const metadata = {
         id: metadataPath.id,
         state: metadataPath.state.type,

package/lib/Types/Mex.js

@@ -2,6 +2,7 @@ export var XWAPaths;
 (function (XWAPaths) {
     XWAPaths["xwa2_newsletter_create"] = "xwa2_newsletter_create";
     XWAPaths["xwa2_newsletter_subscribers"] = "xwa2_newsletter_subscribers";
+    XWAPaths["xwa2_newsletter_subscribed"] = "xwa2_newsletter_subscribed";
     XWAPaths["xwa2_newsletter_view"] = "xwa2_newsletter_view";
     XWAPaths["xwa2_newsletter_metadata"] = "xwa2_newsletter";
     XWAPaths["xwa2_newsletter_admin_count"] = "xwa2_newsletter_admin";
@@ -23,6 +24,7 @@ export var QueryIds;
     QueryIds["UPDATE_METADATA"] = "24250201037901610";
     QueryIds["METADATA"] = "6563316087068696";
     QueryIds["SUBSCRIBERS"] = "9783111038412085";
+    QueryIds["SUBSCRIBED"] = "6388546374527196";
     QueryIds["FOLLOW"] = "24404358912487870";
     QueryIds["UNFOLLOW"] = "9767147403369991";
     QueryIds["MUTE"] = "29766401636284406";

package/lib/Utils/messages-media.js

@@ -683,7 +683,10 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
                         directPath: result.direct_path,
                         meta_hmac: result.meta_hmac,
                         fbid: result.fbid,
-                        ts: result.ts
+                        ts: result.ts,
+                        // Lia@Changes --- capture newsletter thumbnail info returned by the server (server_thumb_gen=1)
+                        thumbnailDirectPath: result.thumbnail_info?.thumbnail_direct_path,
+                        thumbnailSha256: result.thumbnail_info?.thumbnail_sha256
                     };
                     break;
                 }

package/lib/Utils/messages.js

@@ -226,18 +226,52 @@ export const prepareWAMessageMedia = async (message, options) => {
     }
     const isNewsletter = !!options.jid && isJidNewsletter(options.jid);
     if (isNewsletter) {
+        // Channel media follows the @zanta/baileys proven method: the file is
+        // uploaded RAW (server-opaque, no mediaKey / AES handshake) and the
+        // message carries only url, directPath, fileSha256 and fileLength.
+        //
+        // The critical detail is that `newsletter: true` is deliberately NOT
+        // passed to options.upload(). Passing it selects
+        // NEWSLETTER_MEDIA_PATH_MAP (/newsletter/newsletter-audio, plus
+        // &server_thumb_gen=1), which returns a /m1/v/t24/... directPath that the
+        // channel client cannot use for playback — the post renders but never
+        // plays, or the client falls back to the "your version of WhatsApp
+        // doesn't support this update" placeholder. Omitting the flag keeps the
+        // standard MEDIA_PATH_MAP (/mms/audio) upload, which is what the working
+        // channel-media implementation actually does.
         logger?.info({ key: cacheableKey }, 'Preparing raw media for newsletter');
         const { filePath, fileSha256, fileLength } = await getRawMediaUploadData(uploadData.media, options.mediaTypeOverride || mediaType, logger);
         const fileSha256B64 = fileSha256.toString('base64');
         const { mediaUrl, directPath } = await options.upload(filePath, {
             fileEncSha256B64: fileSha256B64,
             mediaType: mediaType,
-            timeoutMs: options.mediaUploadTimeoutMs,
-            newsletter: true
+            // Channel media MUST go up on the newsletter path (/newsletter/newsletter-*).
+            // On the plain /mms/* path a channel post streams for playback but a
+            // full download comes back truncated — the channel media service only
+            // resolves newsletter-path directPaths. This is also what upstream
+            // ishumdz-bail does; the flag was the one thing lost in the port.
+            newsletter: true,
+            timeoutMs: options.mediaUploadTimeoutMs
         });
+        // Additive on top of the @zanta method: build the inline jpegThumbnail
+        // from the raw file we still have on disk. Channel clients render the
+        // bubble straight from this inline thumbnail, so skipping it makes an
+        // otherwise-valid image post look broken. Non-fatal — a failure here
+        // just means the client has to fetch the full image.
+        if ((mediaType === 'image' || mediaType === 'video') && typeof uploadData.jpegThumbnail === 'undefined') {
+            try {
+                const { thumbnail, originalImageDimensions } = await generateThumbnail(filePath, mediaType, options);
+                uploadData.jpegThumbnail = thumbnail;
+                if (!uploadData.width && originalImageDimensions) {
+                    uploadData.width = originalImageDimensions.width;
+                    uploadData.height = originalImageDimensions.height;
+                }
+            } catch (e) {
+                logger?.warn({ err: e?.message }, 'newsletter thumbnail generation failed');
+            }
+        }
         await fs.unlink(filePath);
         const obj = WAProto.Message.fromObject({
-            // todo: add more support here
             [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
                 url: mediaUrl,
                 directPath,
@@ -260,6 +294,7 @@ export const prepareWAMessageMedia = async (message, options) => {
         }
         return obj;
     }
+
     const requiresDurationComputation = mediaType === 'audio' && typeof uploadData.seconds === 'undefined';
     const requiresThumbnailComputation = (mediaType === 'image' || mediaType === 'video') && typeof uploadData['jpegThumbnail'] === 'undefined';
     const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true && typeof uploadData.waveform === 'undefined';
@@ -1250,8 +1285,10 @@ export const generateWAMessageFromContent = (jid, message, options) => {
     const innerMessage = normalizeMessageContent(message);
     const key = getContentType(innerMessage);
     const timestamp = unixTimestampSeconds(options.timestamp);
+    const isNewsletter = isJidNewsletter(jid);
     const { quoted, userJid } = options;
-    if (quoted && !isJidNewsletter(jid)) {
+    // Lia@Changes --- allow quoting inside newsletters: only skip remoteJid for same-chat quotes
+    if (quoted) {
         const participant = quoted.key.fromMe
             ? userJid // TODO: Add support for LIDs
             : quoted.participant || quoted.key.participant || quoted.key.remoteJid;
@@ -1269,7 +1306,8 @@ export const generateWAMessageFromContent = (jid, message, options) => {
         contextInfo.quotedMessage = quotedMsg;
         // if a participant is quoted, then it must be a group
         // hence, remoteJid of group must also be entered
-        if (jid !== quoted.key.remoteJid) {
+        // newsletters don't carry remoteJid on quotes
+        if (!isNewsletter && jid !== quoted.key.remoteJid) {
             contextInfo.remoteJid = quoted.key.remoteJid;
         }
         if (contextInfo && innerMessage[key]) {
@@ -1350,7 +1388,11 @@ export const normalizeMessageContent = (content) => {
             message?.editedMessage ||
             message?.associatedChildMessage ||
             message?.groupStatusMessage ||
-            message?.groupStatusMessageV2);
+            message?.groupStatusMessageV2 ||
+            // newsletter admin profile wrappers ( Lia fork parity )
+            message?.newsletterAdminProfileMessage ||
+            message?.newsletterAdminProfileMessageV2 ||
+            message?.newsletterAdminProfileStatusMessage);
     }
 };
 /**

package/lib/index.js

@@ -54,6 +54,8 @@ export const newsletterReact = NewsletterPro.newsletterReact;
 export const newsletterGetMessages = NewsletterPro.newsletterGetMessages;
 export const newsletterSearch = NewsletterPro.newsletterSearch;
 export const newsletterList = NewsletterPro.newsletterList;
+// list all newsletters the account follows (Lia fork parity)
+export const newsletterSubscribed = (sock) => sock?.newsletterSubscribed?.();
 
 // Pro Methods - Status
 export const sendStatusText = StatusPro.sendStatusText;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ishumdz-bail",
-    "version": "1.0.13",
+    "version": "1.0.15",
     "description": "WhatsApp API Modification By Lovely",
     "keywords": [
         "whatsapp",