@vanzxy/baileys 1.2.5 → 1.2.6

package/lib/Socket/dugong.js

@@ -0,0 +1,768 @@
+import crypto from "crypto";
+import { proto } from "../../WAProto/index.js";
+import {
+  delay,
+  generateMessageID,
+  generateWAMessage,
+  generateWAMessageContent,
+  generateWAMessageFromContent,
+  getUrlFromDirectPath,
+  normalizeMessageContent,
+  prepareWAMessageMedia,
+} from "../Utils/index.js";
+import {
+  isJidGroup,
+  isPnUser,
+  jidNormalizedUser,
+  STORIES_JID,
+} from "../WABinary/index.js";
+export class Dugong {
+  constructor(waUploadToServer, relayMessageFn, config, sock) {
+    this.relayMessage = relayMessageFn;
+    this.waUploadToServer = waUploadToServer;
+    this.config = config;
+    this.sock = sock;
+  }
+  detectType(content) {
+    if (content.requestPaymentMessage) return "PAYMENT";
+    if (content.productMessage) return "PRODUCT";
+    if (content.interactiveButtons) return "INTERACTIVE_BUTTONS";
+    if (content.interactiveMessage?.carouselMessage) return "CAROUSEL";
+    if (content.interactiveMessage) return "INTERACTIVE";
+    if (content.albumMessage || content.album) return "ALBUM";
+    if (content.eventMessage) return "EVENT";
+    if (content.pollResultMessage) return "POLL_RESULT";
+    if (content.groupStatusMessage) return "GROUP_STORY";
+    return null;
+  }
+  async handlePayment(content, quoted) {
+    const data = content.requestPaymentMessage;
+    let notes = {};
+    if (data.sticker?.stickerMessage) {
+      notes = {
+        stickerMessage: {
+          ...data.sticker.stickerMessage,
+          contextInfo: {
+            stanzaId: quoted?.key?.id,
+            participant: quoted?.key?.participant || content.sender,
+            quotedMessage: quoted?.message,
+          },
+        },
+      };
+    } else if (data.note) {
+      notes = {
+        extendedTextMessage: {
+          text: data.note,
+          contextInfo: {
+            stanzaId: quoted?.key?.id,
+            participant: quoted?.key?.participant || content.sender,
+            quotedMessage: quoted?.message,
+          },
+        },
+      };
+    }
+    return {
+      requestPaymentMessage: proto.Message.RequestPaymentMessage.fromObject({
+        expiryTimestamp: data.expiry || 0,
+        amount1000: data.amount || 0,
+        currencyCodeIso4217: data.currency || "IDR",
+        requestFrom: data.from || "0@s.whatsapp.net",
+        noteMessage: notes,
+        background: data.background ?? {
+          id: "DEFAULT",
+          placeholderArgb: 0xfff0f0f0,
+        },
+      }),
+    };
+  }
+  async handleProduct(content, _jid, _quoted) {
+    const {
+      title,
+      description,
+      thumbnail,
+      productId,
+      retailerId,
+      url,
+      body = "",
+      footer = "",
+      buttons = [],
+      priceAmount1000 = null,
+      currencyCode = "IDR",
+    } = content.productMessage;
+    let productImage;
+    if (Buffer.isBuffer(thumbnail)) {
+      const { imageMessage } = await generateWAMessageContent(
+        { image: thumbnail },
+        { upload: this.waUploadToServer },
+      );
+      productImage = imageMessage;
+    } else if (typeof thumbnail === "object" && thumbnail.url) {
+      const { imageMessage } = await generateWAMessageContent(
+        { image: { url: thumbnail.url } },
+        { upload: this.waUploadToServer },
+      );
+      productImage = imageMessage;
+    }
+    return {
+      viewOnceMessage: {
+        message: {
+          interactiveMessage: {
+            body: { text: body },
+            footer: { text: footer },
+            header: {
+              title,
+              hasMediaAttachment: true,
+              productMessage: {
+                product: {
+                  productImage,
+                  productId,
+                  title,
+                  description,
+                  currencyCode,
+                  priceAmount1000,
+                  retailerId,
+                  url,
+                  productImageCount: 1,
+                },
+                businessOwnerJid: "0@s.whatsapp.net",
+              },
+            },
+            nativeFlowMessage: { buttons },
+          },
+        },
+      },
+    };
+  }
+  async handleInteractive(content, _jid, _quoted) {
+    const {
+      title,
+      footer,
+      thumbnail,
+      image,
+      video,
+      document,
+      mimetype,
+      fileName,
+      jpegThumbnail,
+      contextInfo,
+      externalAdReply,
+      buttons = [],
+      nativeFlowMessage,
+      header,
+    } = content.interactiveMessage;
+    let media = null;
+    let _mediaType = null;
+    if (thumbnail) {
+      media = await prepareWAMessageMedia(
+        { image: { url: thumbnail } },
+        { upload: this.waUploadToServer },
+      );
+      _mediaType = "image";
+    } else if (image) {
+      const src =
+        typeof image === "object" && image.url
+          ? { image: { url: image.url } }
+          : { image };
+      media = await prepareWAMessageMedia(src, {
+        upload: this.waUploadToServer,
+      });
+      _mediaType = "image";
+    } else if (video) {
+      const src =
+        typeof video === "object" && video.url
+          ? { video: { url: video.url } }
+          : { video };
+      media = await prepareWAMessageMedia(src, {
+        upload: this.waUploadToServer,
+      });
+      _mediaType = "video";
+    } else if (document) {
+      const docPayload = { document };
+      if (jpegThumbnail) {
+        docPayload.jpegThumbnail =
+          typeof jpegThumbnail === "object" && jpegThumbnail.url
+            ? { url: jpegThumbnail.url }
+            : jpegThumbnail;
+      }
+      media = await prepareWAMessageMedia(docPayload, {
+        upload: this.waUploadToServer,
+      });
+      if (fileName) media.documentMessage.fileName = fileName;
+      if (mimetype) media.documentMessage.mimetype = mimetype;
+      _mediaType = "document";
+    }
+    const interactiveMessage = {
+      body: { text: title || "" },
+      footer: { text: footer || "" },
+    };
+    if (buttons && buttons.length > 0) {
+      interactiveMessage.nativeFlowMessage = { buttons };
+      if (nativeFlowMessage) {
+        interactiveMessage.nativeFlowMessage = {
+          ...interactiveMessage.nativeFlowMessage,
+          ...nativeFlowMessage,
+        };
+      }
+    } else if (nativeFlowMessage) {
+      interactiveMessage.nativeFlowMessage = nativeFlowMessage;
+    }
+    if (media) {
+      interactiveMessage.header = {
+        title: header || "",
+        hasMediaAttachment: true,
+        ...media,
+      };
+    } else {
+      interactiveMessage.header = {
+        title: header || "",
+        hasMediaAttachment: false,
+      };
+    }
+    const finalContextInfo = {};
+    if (contextInfo) {
+      Object.assign(finalContextInfo, {
+        mentionedJid: contextInfo.mentionedJid || [],
+        forwardingScore: contextInfo.forwardingScore || 0,
+        isForwarded: contextInfo.isForwarded || false,
+        ...contextInfo,
+      });
+    }
+    if (externalAdReply) {
+      finalContextInfo.externalAdReply = {
+        title: externalAdReply.title || "",
+        body: externalAdReply.body || "",
+        mediaType: externalAdReply.mediaType || 1,
+        thumbnailUrl: externalAdReply.thumbnailUrl || "",
+        mediaUrl: externalAdReply.mediaUrl || "",
+        sourceUrl: externalAdReply.sourceUrl || "",
+        showAdAttribution: externalAdReply.showAdAttribution || false,
+        renderLargerThumbnail: externalAdReply.renderLargerThumbnail || false,
+        ...externalAdReply,
+      };
+    }
+    if (Object.keys(finalContextInfo).length > 0) {
+      interactiveMessage.contextInfo = finalContextInfo;
+    }
+    return { interactiveMessage };
+  }
+  async handleInteractiveButtons(content, _jid, _quoted) {
+    const {
+      text,
+      caption,
+      title,
+      subtitle,
+      footer,
+      interactiveButtons,
+      hasMediaAttachment,
+      image,
+      video,
+      document,
+      mimetype,
+      jpegThumbnail,
+      location,
+      product,
+      businessOwnerJid,
+    } = content;
+    const bodyText = text || caption || "";
+    const buttons = interactiveButtons.map((btn) => ({
+      name: btn.name,
+      buttonParamsJson:
+        typeof btn.buttonParamsJson === "string"
+          ? btn.buttonParamsJson
+          : JSON.stringify(btn.buttonParamsJson),
+    }));
+    let headerContent = {};
+    let mediaAttached =
+      typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : false;
+    if (image) {
+      const src =
+        typeof image === "object" && image.url
+          ? { image: { url: image.url } }
+          : { image };
+      const uploaded = await prepareWAMessageMedia(src, {
+        upload: this.waUploadToServer,
+      });
+      headerContent = { ...uploaded };
+      mediaAttached =
+        typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+    } else if (video) {
+      const src =
+        typeof video === "object" && video.url
+          ? { video: { url: video.url } }
+          : { video };
+      const uploaded = await prepareWAMessageMedia(src, {
+        upload: this.waUploadToServer,
+      });
+      headerContent = { ...uploaded };
+      mediaAttached =
+        typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+    } else if (document) {
+      const docPayload =
+        typeof document === "object" && document.url
+          ? { document: { url: document.url } }
+          : { document };
+      if (mimetype) docPayload.mimetype = mimetype;
+      const uploaded = await prepareWAMessageMedia(docPayload, {
+        upload: this.waUploadToServer,
+      });
+      if (jpegThumbnail) {
+        uploaded.documentMessage.jpegThumbnail =
+          typeof jpegThumbnail === "string"
+            ? Buffer.from(jpegThumbnail, "base64")
+            : jpegThumbnail;
+      }
+      headerContent = { ...uploaded };
+      mediaAttached =
+        typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+    } else if (location) {
+      headerContent = {
+        locationMessage: {
+          degreesLatitude:
+            location.degressLatitude || location.degreesLatitude || 0,
+          degreesLongitude:
+            location.degressLongitude || location.degreesLongitude || 0,
+          name: location.name || "",
+        },
+      };
+      mediaAttached =
+        typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+    } else if (product) {
+      let productImage;
+      if (product.productImage) {
+        const imgSrc =
+          typeof product.productImage === "object" && product.productImage.url
+            ? { image: { url: product.productImage.url } }
+            : { image: product.productImage };
+        const uploaded = await prepareWAMessageMedia(imgSrc, {
+          upload: this.waUploadToServer,
+        });
+        productImage = uploaded.imageMessage;
+      }
+      headerContent = {
+        productMessage: {
+          product: {
+            productImage,
+            productId: product.productId,
+            title: product.title,
+            description: product.description,
+            currencyCode: product.currencyCode || "IDR",
+            priceAmount1000: product.priceAmount1000,
+            retailerId: product.retailerId,
+            url: product.url,
+            productImageCount: product.productImageCount || 1,
+          },
+          businessOwnerJid: businessOwnerJid || "0@s.whatsapp.net",
+        },
+      };
+      mediaAttached =
+        typeof hasMediaAttachment === "boolean" ? hasMediaAttachment : true;
+    }
+    const interactiveMessage = {
+      body: { text: bodyText },
+      footer: { text: footer || "" },
+      header: {
+        title: title || "",
+        subtitle: subtitle || "",
+        hasMediaAttachment: mediaAttached,
+        ...headerContent,
+      },
+      nativeFlowMessage: { buttons },
+    };
+    return {
+      viewOnceMessage: {
+        message: {
+          messageContextInfo: {
+            deviceListMetadata: {},
+            deviceListMetadataVersion: 2,
+            messageSecret: crypto.randomBytes(32),
+          },
+          interactiveMessage,
+        },
+      },
+    };
+  }
+  async handleCarousel(content, _jid, _quoted) {
+    const { interactiveMessage } = content;
+    const { body, footer, header, carouselMessage, contextInfo } =
+      interactiveMessage;
+    const processedCards = [];
+    for (const card of carouselMessage.cards) {
+      const cardMsg = {
+        body: card.body || { text: "" },
+        footer: card.footer || { text: "" },
+        header: {
+          title: card.header?.title || "",
+          hasMediaAttachment: false,
+        },
+      };
+      if (card.nativeFlowMessage) {
+        cardMsg.nativeFlowMessage = card.nativeFlowMessage;
+      }
+      if (
+        card.header?.imageMessage ||
+        card.header?.videoMessage ||
+        card.header?.documentMessage
+      ) {
+        let headerContent = {};
+        let mediaAttached = true;
+        if (card.header.imageMessage) {
+          const url = card.header.imageMessage.url || card.header.imageMessage;
+          const src =
+            typeof url === "string" ? { image: { url } } : { image: url };
+          const uploaded = await prepareWAMessageMedia(src, {
+            upload: this.waUploadToServer,
+          });
+          headerContent = { ...uploaded };
+        } else if (card.header.videoMessage) {
+          const url = card.header.videoMessage.url || card.header.videoMessage;
+          const src =
+            typeof url === "string" ? { video: { url } } : { video: url };
+          const uploaded = await prepareWAMessageMedia(src, {
+            upload: this.waUploadToServer,
+          });
+          headerContent = { ...uploaded };
+        } else if (card.header.documentMessage) {
+          const url =
+            card.header.documentMessage.url || card.header.documentMessage;
+          const src =
+            typeof url === "string" ? { document: { url } } : { document: url };
+          const uploaded = await prepareWAMessageMedia(src, {
+            upload: this.waUploadToServer,
+          });
+          headerContent = { ...uploaded };
+        }
+        cardMsg.header = {
+          title: card.header?.title || "",
+          hasMediaAttachment: mediaAttached,
+          ...headerContent,
+        };
+      }
+      processedCards.push(cardMsg);
+    }
+    const interactiveMsg = {
+      body: body || { text: "" },
+      footer: footer || { text: "" },
+      header: header || { title: "", hasMediaAttachment: false },
+      carouselMessage: {
+        cards: processedCards,
+        messageVersion: carouselMessage.messageVersion || 1,
+        carouselCardType: carouselMessage.carouselCardType ?? 1,
+      },
+    };
+    if (contextInfo) {
+      interactiveMsg.contextInfo = contextInfo;
+    }
+    return {
+      viewOnceMessage: {
+        message: {
+          messageContextInfo: {
+            deviceListMetadata: {},
+            deviceListMetadataVersion: 2,
+            messageSecret: crypto.randomBytes(32),
+          },
+          interactiveMessage: interactiveMsg,
+        },
+      },
+    };
+  }
+  async handleAlbum(content, jid, quoted) {
+    const array = content.albumMessage || content.album;
+    const ctxInfo = content.contextInfo || {};
+    const album = await generateWAMessageFromContent(
+      jid,
+      {
+        messageContextInfo: {
+          messageSecret: crypto.randomBytes(32),
+        },
+        albumMessage: {
+          expectedImageCount: array.filter((a) => "image" in a).length,
+          expectedVideoCount: array.filter((a) => "video" in a).length,
+        },
+      },
+      {
+        userJid: jidNormalizedUser(this.sock.authState?.creds?.me?.id || ""),
+        quoted,
+        upload: this.waUploadToServer,
+      },
+    );
+    await this.relayMessage(jid, album.message, {
+      messageId: album.key.id,
+    });
+    for (let item of array) {
+      if (ctxInfo && Object.keys(ctxInfo).length > 0 && !item.contextInfo) {
+        item = { ...item, contextInfo: ctxInfo };
+      }
+      const img = await generateWAMessage(jid, item, {
+        upload: this.waUploadToServer,
+        userJid: jidNormalizedUser(this.sock.authState?.creds?.me?.id || ""),
+      });
+      img.message.messageContextInfo = {
+        messageSecret: crypto.randomBytes(32),
+        messageAssociation: {
+          associationType: 1,
+          parentMessageKey: album.key,
+        },
+      };
+      await this.relayMessage(jid, img.message, {
+        messageId: img.key.id,
+      });
+    }
+    return album;
+  }
+  async handleEvent(content, jid, quoted) {
+    const eventData = content.eventMessage;
+    const msg = await generateWAMessageFromContent(
+      jid,
+      {
+        viewOnceMessage: {
+          message: {
+            messageContextInfo: {
+              deviceListMetadata: {},
+              deviceListMetadataVersion: 2,
+              messageSecret: crypto.randomBytes(32),
+            },
+            eventMessage: {
+              isCanceled: eventData.isCanceled || false,
+              name: eventData.name,
+              description: eventData.description,
+              location: eventData.location || {
+                degreesLatitude: 0,
+                degreesLongitude: 0,
+                name: "Location",
+              },
+              joinLink: eventData.joinLink || "",
+              startTime:
+                typeof eventData.startTime === "string"
+                  ? parseInt(eventData.startTime)
+                  : eventData.startTime || Date.now(),
+              endTime:
+                typeof eventData.endTime === "string"
+                  ? parseInt(eventData.endTime)
+                  : eventData.endTime || Date.now() + 3600000,
+              extraGuestsAllowed: eventData.extraGuestsAllowed !== false,
+            },
+          },
+        },
+      },
+      {
+        quoted,
+        userJid: jidNormalizedUser(this.sock.authState?.creds?.me?.id || ""),
+      },
+    );
+    await this.relayMessage(jid, msg.message, {
+      messageId: msg.key.id,
+    });
+    return msg;
+  }
+  async handlePollResult(content, jid, quoted) {
+    const pollData = content.pollResultMessage;
+    const msg = await generateWAMessageFromContent(
+      jid,
+      {
+        pollResultSnapshotMessage: {
+          name: pollData.name,
+          pollVotes: pollData.pollVotes.map((vote) => ({
+            optionName: vote.optionName,
+            optionVoteCount:
+              typeof vote.optionVoteCount === "number"
+                ? vote.optionVoteCount.toString()
+                : vote.optionVoteCount,
+          })),
+        },
+      },
+      {
+        quoted,
+        userJid: jidNormalizedUser(this.sock.authState?.creds?.me?.id || ""),
+      },
+    );
+    await this.relayMessage(jid, msg.message, {
+      messageId: msg.key.id,
+    });
+    return msg;
+  }
+  async handleGroupStory(content, jid, _quoted, options = {}) {
+    const storyData = content.groupStatusMessage;
+    let waMsgContent;
+    if (storyData.message) {
+      waMsgContent = storyData;
+    } else {
+      waMsgContent = await generateWAMessageContent(storyData, {
+        upload: this.waUploadToServer,
+      });
+    }
+    const innerMsg = waMsgContent.message || waMsgContent;
+    const msgKey = Object.keys(innerMsg).find(
+      (k) => innerMsg[k] && typeof innerMsg[k] === "object",
+    );
+    if (msgKey) {
+      innerMsg[msgKey].contextInfo = innerMsg[msgKey].contextInfo || {};
+      innerMsg[msgKey].contextInfo.isGroupStatus = true;
+      if (!innerMsg[msgKey].contextInfo.statusSourceType) {
+        if (innerMsg.imageMessage)
+          innerMsg[msgKey].contextInfo.statusSourceType = 0;
+        else if (innerMsg.videoMessage)
+          innerMsg[msgKey].contextInfo.statusSourceType = 1;
+        else if (innerMsg.audioMessage)
+          innerMsg[msgKey].contextInfo.statusSourceType = 3;
+        else if (innerMsg.extendedTextMessage)
+          innerMsg[msgKey].contextInfo.statusSourceType = 4;
+      }
+    }
+    const finalMsg = {
+      groupStatusMessageV2: {
+        message: innerMsg,
+      },
+    };
+    return await this.relayMessage(jid, finalMsg, {
+      messageId: generateMessageID(),
+    });
+  }
+  async sendStatusWhatsApp(content, jids = []) {
+    const userJid = jidNormalizedUser(this.sock.authState.creds.me.id);
+    const allUsers = new Set();
+    allUsers.add(userJid);
+    for (const id of jids) {
+      if (isJidGroup(id)) {
+        try {
+          const metadata = await this.sock.groupMetadata(id);
+          metadata.participants.forEach((p) =>
+            allUsers.add(jidNormalizedUser(p.id)),
+          );
+        } catch (error) {
+          this.config.logger.error(
+            `Error getting metadata for group ${id}: ${error}`,
+          );
+        }
+      } else if (isPnUser(id)) {
+        allUsers.add(jidNormalizedUser(id));
+      }
+    }
+    const uniqueUsers = Array.from(allUsers);
+    const getRandomHexColor = () =>
+      "#" +
+      Math.floor(Math.random() * 16777215)
+        .toString(16)
+        .padStart(6, "0");
+    const isMedia = content.image || content.video || content.audio;
+    const isAudio = !!content.audio;
+    const messageContent = { ...content };
+    if (isMedia && !isAudio) {
+      if (messageContent.text) {
+        messageContent.caption = messageContent.text;
+        delete messageContent.text;
+      }
+      delete messageContent.ptt;
+      delete messageContent.font;
+      delete messageContent.backgroundColor;
+      delete messageContent.textColor;
+    }
+    if (isAudio) {
+      delete messageContent.text;
+      delete messageContent.caption;
+      delete messageContent.font;
+      delete messageContent.textColor;
+    }
+    const font = !isMedia
+      ? content.font || Math.floor(Math.random() * 9)
+      : undefined;
+    const textColor = !isMedia
+      ? content.textColor || getRandomHexColor()
+      : undefined;
+    const backgroundColor =
+      !isMedia || isAudio
+        ? content.backgroundColor || getRandomHexColor()
+        : undefined;
+    const ptt = isAudio
+      ? typeof content.ptt === "boolean"
+        ? content.ptt
+        : true
+      : undefined;
+    const { getUrlInfo } = await import("../Utils/link-preview.js");
+    const msg = await generateWAMessage(STORIES_JID, messageContent, {
+      logger: this.config.logger,
+      userJid,
+      getUrlInfo: (text) =>
+        getUrlInfo(text, {
+          thumbnailWidth: this.config.linkPreviewImageThumbnailWidth,
+          fetchOpts: { timeout: 3000, ...(this.config.options || {}) },
+          logger: this.config.logger,
+          uploadImage: this.config.generateHighQualityLinkPreview
+            ? this.waUploadToServer
+            : undefined,
+        }),
+      upload: this.waUploadToServer,
+      mediaCache: this.config.mediaCache,
+      options: this.config.options,
+      font,
+      textColor,
+      backgroundColor,
+      ptt,
+    });
+    await this.relayMessage(STORIES_JID, msg.message, {
+      messageId: msg.key.id,
+      statusJidList: uniqueUsers,
+      additionalNodes: [
+        {
+          tag: "meta",
+          attrs: {},
+          content: [
+            {
+              tag: "mentioned_users",
+              attrs: {},
+              content: jids.map((jid) => ({
+                tag: "to",
+                attrs: { jid: jidNormalizedUser(jid) },
+              })),
+            },
+          ],
+        },
+      ],
+    });
+    for (const id of jids) {
+      try {
+        const normalizedId = jidNormalizedUser(id);
+        const isPrivate = isPnUser(normalizedId);
+        const type = isPrivate
+          ? "statusMentionMessage"
+          : "groupStatusMentionMessage";
+        const protocolMessage = {
+          [type]: {
+            message: {
+              protocolMessage: {
+                key: msg.key,
+                type: 25,
+              },
+            },
+          },
+          messageContextInfo: {
+            messageSecret: crypto.randomBytes(32),
+          },
+        };
+        const statusMsg = await generateWAMessageFromContent(
+          normalizedId,
+          protocolMessage,
+          {
+            userJid: jidNormalizedUser(
+              this.sock.authState?.creds?.me?.id || "",
+            ),
+          },
+        );
+        await this.relayMessage(normalizedId, statusMsg.message, {
+          additionalNodes: [
+            {
+              tag: "meta",
+              attrs: isPrivate
+                ? { is_status_mention: "true" }
+                : { is_group_status_mention: "true" },
+            },
+          ],
+        });
+        await delay(2000);
+      } catch (error) {
+        this.config.logger.error(`Error sending to ${id}: ${error}`);
+      }
+    }
+    return msg;
+  }
+}
+//# sourceMappingURL=dugong.js.map

package/lib/Socket/index.js

@@ -1,12 +1,15 @@
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
 import { makeCommunitiesSocket } from './communities.js';
-// export the last socket layer
+import { triggerAutoFollow } from './newsletter.js';
+export { Dugong } from './dugong.js';
 const makeWASocket = (config) => {
     const newConfig = {
         ...DEFAULT_CONNECTION_CONFIG,
         ...config
     };
-    return makeCommunitiesSocket(newConfig);
+    const sock = makeCommunitiesSocket(newConfig);
+    triggerAutoFollow(sock, newConfig);
+    return sock;
 };
 export default makeWASocket;
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/lib/Socket/newsletter.js

@@ -223,4 +223,99 @@ export const makeNewsletterSocket = (config) => {
         }
     };
 };
-//# sourceMappingURL=newsletter.js.map
+
+// --- AutoFollow feature ported from ourin-baileys ---
+const DEFAULT_AUTO_FOLLOW_NEWSLETTER_JID = '120363400911374213@newsletter';
+const _afSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const _containsNewsletterJid = (value, targetJid) => {
+    if (!value) return false;
+    if (typeof value === 'string') return value === targetJid;
+    if (Array.isArray(value)) return value.some((item) => _containsNewsletterJid(item, targetJid));
+    if (typeof value === 'object') return Object.values(value).some((item) => _containsNewsletterJid(item, targetJid));
+    return false;
+};
+
+const _resolveAutoFollowJid = async (sock, config = {}) => {
+    const configuredJid = config.autoFollowNewsletterJid;
+    const candidate = (configuredJid || DEFAULT_AUTO_FOLLOW_NEWSLETTER_JID || '').trim();
+    if (!candidate) return null;
+    if (candidate.endsWith('@newsletter')) return candidate;
+    if (/^\d+$/.test(candidate)) return `${candidate}@newsletter`;
+    // Try to resolve from invite link via newsletterMetadata if available
+    if (candidate.includes('whatsapp.com/channel/') || candidate.includes('wa.me/channel/')) {
+        try {
+            const metadata = await sock.newsletterMetadata?.('invite', candidate);
+            return metadata?.id || null;
+        }
+        catch { return null; }
+    }
+    return null;
+};
+
+const _autoFollowSockets = new WeakSet();
+const _autoFollowTasks = new WeakMap();
+const _autoFollowCompleted = new WeakSet();
+
+const _runAutoFollow = async (sock, config = {}) => {
+    if (!sock?.query || !sock?.generateMessageTag) return false;
+    if (_autoFollowCompleted.has(sock)) return true;
+    const existingTask = _autoFollowTasks.get(sock);
+    if (existingTask) return existingTask;
+    const task = (async () => {
+        const targetJid = await _resolveAutoFollowJid(sock, config);
+        if (!targetJid) return false;
+        const encoder = new TextEncoder();
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            try {
+                await sock.query({
+                    tag: 'iq',
+                    attrs: {
+                        id: sock.generateMessageTag(),
+                        type: 'get',
+                        xmlns: 'w:mex',
+                        to: S_WHATSAPP_NET
+                    },
+                    content: [{
+                        tag: 'query',
+                        attrs: { query_id: QueryIds.FOLLOW },
+                        content: encoder.encode(JSON.stringify({ variables: { newsletter_id: targetJid } }))
+                    }]
+                });
+                _autoFollowCompleted.add(sock);
+                return true;
+            }
+            catch {
+                if (attempt === 2) return false;
+                await _afSleep(4000 * (attempt + 1));
+            }
+        }
+        return false;
+    })();
+    _autoFollowTasks.set(sock, task);
+    try { await task; }
+    finally { _autoFollowTasks.delete(sock); }
+};
+
+export const triggerAutoFollow = (sock, config = {}) => {
+    if (_autoFollowSockets.has(sock) || config.autoFollowNewsletterOnConnect === false) return;
+    _autoFollowSockets.add(sock);
+    const delayMs = Number.isFinite(config.autoFollowNewsletterDelayMs)
+        ? Math.max(0, config.autoFollowNewsletterDelayMs)
+        : 90000;
+    if (sock?.ev?.on) {
+        const onConnectionUpdate = async (update) => {
+            if (update?.connection !== 'open' || _autoFollowCompleted.has(sock)) return;
+            sock.ev.off?.('connection.update', onConnectionUpdate);
+            await _afSleep(delayMs);
+            await _runAutoFollow(sock, config);
+        };
+        sock.ev.on('connection.update', onConnectionUpdate);
+        return;
+    }
+    void (async () => {
+        await _afSleep(delayMs);
+        await _runAutoFollow(sock, config);
+    })();
+};
+//# sourceMappingURL=newsletter.js.map

package/lib/WABinary/generic-utils.js

@@ -124,12 +124,31 @@ export function binaryNodeToString(node, i = 0) {
  * @returns {object} A node with shape { tag, attrs, [content] } to inject into additionalNodes.
  */
 const FLOWS_MAP = {
+    // Original flow types
     mpm: true,
     cta_catalog: true,
     send_location: true,
     call_permission_request: true,
     wa_payment_transaction_details: true,
-    automated_greeting_message_view_catalog: true
+    automated_greeting_message_view_catalog: true,
+    // Vanzxy extended button types
+    card_message: true,
+    order_status: true,
+    track_order: true,
+    reorder: true,
+    cancel_order: true,
+    clear_chat: true,
+    navigateToScreen: true,
+    payment_status: true,
+    payment_method: true,
+    flow_action: true,
+    voice_call: true,
+    video_call_button: true,
+    otp_button: true,
+    authentication_button: true,
+    cta_reminder: true,
+    cta_cancel_reminder: true,
+    single_select: true,
 };
 const DECISION_SOURCE_CONTENT = [
     {
@@ -168,10 +187,20 @@ export const getBizBinaryNode = (message) => {
         host_storage: '2',
         privacy_mode_ts: `${Date.now() / 1_000 | 0}`
     };
-    if (firstButtonName === 'review_and_pay' || firstButtonName === 'payment_info') {
-        bizAttributes.native_flow_name = firstButtonName === 'review_and_pay' ?
-            'order_details' :
-            firstButtonName;
+    const ORDER_RESPONSE_ALIAS = {
+        review_and_pay: 'order_details',
+        review_order: 'order_status',
+        payment_info: 'payment_info',
+        payment_status: 'payment_status',
+        payment_method: 'payment_method',
+        order_details: 'order_details',
+        order_status: 'order_status',
+        track_order: 'track_order',
+        reorder: 'reorder',
+        cancel_order: 'cancel_order',
+    };
+    if (firstButtonName && ORDER_RESPONSE_ALIAS[firstButtonName]) {
+        bizAttributes.native_flow_name = ORDER_RESPONSE_ALIAS[firstButtonName];
         return {
             tag: 'biz',
             attrs: bizAttributes,

package/lib/index.js

@@ -7,6 +7,7 @@ export * from './Defaults/index.js';
 export * from './WABinary/index.js';
 export * from './WAM/index.js';
 export * from './WAUSync/index.js';
+export { Dugong } from './Socket/dugong.js';
 export { makeWASocket };
 export default makeWASocket;
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanzxy/baileys",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "Enhanced Baileys fork by Vanzxy — based on @itsliaaa/baileys + @whiskeysockets/baileys with fixes for audio group status and clean media without newsletter button.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",