ishumdz-bail 1.0.5 → 1.0.6

package/lib/Pro/chats.js

@@ -0,0 +1,119 @@
+/**
+ * High-level Pro Messaging & Chat Actions for chama-bailez-pro
+ */
+
+/**
+ * Edit a previously sent message
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target chat JID
+ * @param {any} key Key of message to edit
+ * @param {string} newText New text content
+ */
+export async function editMessage(sock, jid, key, newText) {
+    if (!key) throw new Error('Message key is required to edit');
+    return await sock.sendMessage(jid, {
+        text: newText,
+        edit: key
+    });
+}
+
+/**
+ * Revoke/delete a message
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target chat JID
+ * @param {any} key Key of message to delete
+ */
+export async function deleteMessage(sock, jid, key) {
+    if (!key) throw new Error('Message key is required to delete');
+    return await sock.sendMessage(jid, {
+        delete: key
+    });
+}
+
+/**
+ * Pin a message in chat
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target chat JID
+ * @param {any} key Key of message to pin
+ * @param {number} [durationInSeconds=86400] 86400 (24h), 604800 (7d), or 2592000 (30d)
+ */
+export async function pinMessage(sock, jid, key, durationInSeconds = 86400) {
+    if (!key) throw new Error('Message key is required to pin');
+    return await sock.sendMessage(jid, {
+        pin: key,
+        type: 1, // 1 = pin, 2 = unpin
+        time: durationInSeconds
+    });
+}
+
+/**
+ * Unpin a message in chat
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target chat JID
+ * @param {any} key Key of message to unpin
+ */
+export async function unpinMessage(sock, jid, key) {
+    if (!key) throw new Error('Message key is required to unpin');
+    return await sock.sendMessage(jid, {
+        pin: key,
+        type: 2
+    });
+}
+
+/**
+ * Star or unstar a message
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target chat JID
+ * @param {any} key Message key
+ * @param {boolean} [star=true] True to star, false to unstar
+ */
+export async function starMessage(sock, jid, key, star = true) {
+    if (!key?.id) throw new Error('Message key with id is required');
+    return await sock.chatModify({
+        star: {
+            messages: [{ id: key.id, fromMe: key.fromMe || false }],
+            star
+        }
+    }, jid);
+}
+
+/**
+ * React to a message with an emoji or remove reaction
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target chat JID
+ * @param {any} key Key of message to react to
+ * @param {string} [emoji=''] Emoji character, or empty string to remove reaction
+ */
+export async function reactMessage(sock, jid, key, emoji = '') {
+    if (!key) throw new Error('Message key is required to react');
+    return await sock.sendMessage(jid, {
+        react: {
+            text: emoji,
+            key
+        }
+    });
+}
+
+/**
+ * Send typing, recording, or online presence
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target chat JID
+ * @param {'composing'|'recording'|'paused'|'available'|'unavailable'} [presence='composing'] 
+ */
+export async function sendPresence(sock, jid, presence = 'composing') {
+    if (presence === 'available' || presence === 'unavailable') {
+        return await sock.sendPresenceUpdate(presence);
+    }
+    return await sock.sendPresenceUpdate(presence, jid);
+}
+
+/**
+ * Send instant quoted text reply
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target chat JID
+ * @param {string} text Message text
+ * @param {any} [quotedMessage] Quoted message object
+ */
+export async function reply(sock, jid, text, quotedMessage = undefined) {
+    return await sock.sendMessage(jid, { text }, { quoted: quotedMessage });
+}

package/lib/Pro/groups.js

@@ -0,0 +1,72 @@
+/**
+ * High-level Pro Group Management API for chama-bailez-pro
+ */
+
+/**
+ * Get group metadata and preview info from invite link/code without joining
+ * @param {any} sock Baileys socket instance
+ * @param {string} inviteCode Group invite code or full WhatsApp invite URL
+ */
+export async function groupGetInviteInfo(sock, inviteCode) {
+    const code = inviteCode.replace(/.*chat\.whatsapp\.com\//, '').trim();
+    return await sock.groupGetInviteInfo(code);
+}
+
+/**
+ * Join a group using an invite code or URL
+ * @param {any} sock Baileys socket instance
+ * @param {string} inviteCode Group invite code or URL
+ */
+export async function groupJoinViaInvite(sock, inviteCode) {
+    const code = inviteCode.replace(/.*chat\.whatsapp\.com\//, '').trim();
+    return await sock.groupAcceptInvite(code);
+}
+
+/**
+ * Toggle announcement mode (only admins can send messages)
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Group JID
+ * @param {boolean} [onlyAdminsCanSend=true] 
+ */
+export async function groupSetAnnouncement(sock, jid, onlyAdminsCanSend = true) {
+    return await sock.groupSettingUpdate(jid, onlyAdminsCanSend ? 'announcement' : 'not_announcement');
+}
+
+/**
+ * Toggle locked mode (only admins can modify group icon/description/name)
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Group JID
+ * @param {boolean} [onlyAdminsCanEdit=true]
+ */
+export async function groupSetLocked(sock, jid, onlyAdminsCanEdit = true) {
+    return await sock.groupSettingUpdate(jid, onlyAdminsCanEdit ? 'locked' : 'unlocked');
+}
+
+/**
+ * List pending membership approval requests in a group
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Group JID
+ */
+export async function groupRequestParticipantsList(sock, jid) {
+    return await sock.groupRequestParticipantsList(jid);
+}
+
+/**
+ * Approve pending join requests
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Group JID
+ * @param {string[]} participants Array of participant JIDs to approve
+ */
+export async function groupApproveParticipants(sock, jid, participants) {
+    return await sock.groupRequestParticipantsUpdate(jid, participants, 'approve');
+}
+
+/**
+ * Reject pending join requests
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Group JID
+ * @param {string[]} participants Array of participant JIDs to reject
+ */
+export async function groupRejectParticipants(sock, jid, participants) {
+    return await sock.groupRequestParticipantsUpdate(jid, participants, 'reject');
+}

package/lib/Pro/index.js

@@ -0,0 +1,69 @@
+import * as PollsPro from './polls.js';
+import * as NewsletterPro from './newsletter.js';
+import * as StatusPro from './status.js';
+import * as ChatsPro from './chats.js';
+import * as GroupsPro from './groups.js';
+import * as ProfilePro from './profile.js';
+
+export * from './polls.js';
+export * from './newsletter.js';
+export * from './status.js';
+export * from './chats.js';
+export * from './groups.js';
+export * from './profile.js';
+
+/**
+ * Attaches all high-level Pro features directly onto the Baileys socket instance
+ * @param {any} sock The Baileys socket instance
+ */
+export function attachProMethods(sock) {
+    if (!sock) return sock;
+
+    // --- 📊 Polls Pro ---
+    sock.sendPoll = (jid, pollData) => PollsPro.sendPoll(sock, jid, pollData);
+    sock.sendPollVote = (jid, pollKeyOrMsg, selectedOptions) => PollsPro.sendPollVote(sock, jid, pollKeyOrMsg, selectedOptions);
+    sock.getAggregatePollVotes = (pollMsg) => PollsPro.getAggregatePollVotes(sock, pollMsg);
+
+    // --- 📢 Newsletter & Channels Pro ---
+    sock.channelVote = (target, option, serverId) => NewsletterPro.channelVote(sock, target, option, serverId);
+    sock.newsletterVoteMessage = (jid, serverId, option) => NewsletterPro.newsletterVoteMessage(sock, jid, serverId, option);
+    sock.newsletterReact = (jid, serverId, reaction) => NewsletterPro.newsletterReact(sock, jid, serverId, reaction);
+    sock.newsletterGetMessages = (jid, count, since, after) => NewsletterPro.newsletterGetMessages(sock, jid, count, since, after);
+    sock.newsletterSearch = (query) => NewsletterPro.newsletterSearch(sock, query);
+    sock.newsletterList = () => NewsletterPro.newsletterList(sock);
+
+    // --- 🟢 Status / Stories Pro ---
+    sock.sendStatusText = (text, options) => StatusPro.sendStatusText(sock, text, options);
+    sock.sendStatusMedia = (media, options) => StatusPro.sendStatusMedia(sock, media, options);
+    sock.readStatus = (key) => StatusPro.readStatus(sock, key);
+    sock.reactStatus = (key, emoji) => StatusPro.reactStatus(sock, key, emoji);
+
+    // --- 💬 Messaging & Chats Pro ---
+    sock.editMessage = (jid, key, newText) => ChatsPro.editMessage(sock, jid, key, newText);
+    sock.deleteMessage = (jid, key) => ChatsPro.deleteMessage(sock, jid, key);
+    sock.pinMessage = (jid, key, durationInSeconds) => ChatsPro.pinMessage(sock, jid, key, durationInSeconds);
+    sock.unpinMessage = (jid, key) => ChatsPro.unpinMessage(sock, jid, key);
+    sock.starMessage = (jid, key, star) => ChatsPro.starMessage(sock, jid, key, star);
+    sock.reactMessage = (jid, key, emoji) => ChatsPro.reactMessage(sock, jid, key, emoji);
+    sock.sendPresence = (jid, presence) => ChatsPro.sendPresence(sock, jid, presence);
+    sock.reply = (jid, text, quotedMessage) => ChatsPro.reply(sock, jid, text, quotedMessage);
+
+    // --- 👥 Group Management Pro ---
+    sock.groupGetInviteInfo = (code) => GroupsPro.groupGetInviteInfo(sock, code);
+    sock.groupJoinViaInvite = (code) => GroupsPro.groupJoinViaInvite(sock, code);
+    sock.groupSetAnnouncement = (jid, onlyAdminsCanSend) => GroupsPro.groupSetAnnouncement(sock, jid, onlyAdminsCanSend);
+    sock.groupSetLocked = (jid, onlyAdminsCanEdit) => GroupsPro.groupSetLocked(sock, jid, onlyAdminsCanEdit);
+    sock.groupRequestParticipantsList = (jid) => GroupsPro.groupRequestParticipantsList(sock, jid);
+    sock.groupApproveParticipants = (jid, participants) => GroupsPro.groupApproveParticipants(sock, jid, participants);
+    sock.groupRejectParticipants = (jid, participants) => GroupsPro.groupRejectParticipants(sock, jid, participants);
+
+    // --- 👤 Profile, Contacts & Calls Pro ---
+    sock.checkNumber = (phoneNumber) => ProfilePro.checkNumber(sock, phoneNumber);
+    sock.setBio = (text) => ProfilePro.setBio(sock, text);
+    sock.updateProfileName = (name) => ProfilePro.updateProfileName(sock, name);
+    sock.setProfilePicture = (jid, content) => ProfilePro.setProfilePicture(sock, jid, content);
+    sock.removeProfilePicture = (jid) => ProfilePro.removeProfilePicture(sock, jid);
+    sock.rejectCall = (callId, callFrom) => ProfilePro.rejectCall(sock, callId, callFrom);
+
+    return sock;
+}

package/lib/Pro/newsletter.js

@@ -0,0 +1,363 @@
+import crypto from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { getBinaryNodeChild, getBinaryNodeChildren } from '../WABinary/index.js';
+
+/**
+ * High-level Pro Newsletter (WhatsApp Channel) API for chama-bailez-pro
+ */
+
+/**
+ * Cast a vote on a WhatsApp channel poll
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Newsletter JID (e.g. 120363427108046852@newsletter)
+ * @param {string|number} serverId Server ID of the poll message
+ * @param {string} option Option text to vote for
+ */
+export async function newsletterVoteMessage(sock, jid, serverId, option) {
+    const sId = serverId.toString();
+    const optionText = option || 'TEST';
+    const optionHash = crypto.createHash('sha256').update(optionText).digest();
+    const optionHashHex = optionHash.toString('hex');
+
+    const channelPollUpdateMsg = {
+        pollUpdateMessage: {
+            pollCreationMessageKey: {
+                remoteJid: jid,
+                id: sId,
+                fromMe: false
+            },
+            senderTimestampMs: Date.now()
+        }
+    };
+
+    const relayResult = await sock.relayMessage(jid, channelPollUpdateMsg, {
+        additionalAttributes: {
+            server_id: sId
+        }
+    });
+
+    try {
+        await sock.query({
+            tag: 'message',
+            attrs: {
+                to: jid,
+                type: 'poll',
+                server_id: sId,
+                id: sock.generateMessageTag()
+            },
+            content: [
+                {
+                    tag: 'poll_vote',
+                    attrs: {
+                        option: optionHashHex
+                    }
+                }
+            ]
+        }).catch(() => {});
+    } catch (e) {}
+
+    return {
+        success: true,
+        channelJid: jid,
+        serverId: sId,
+        option: optionText,
+        optionHashHex,
+        relayResult
+    };
+}
+
+/**
+ * React to a channel post or remove reaction
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Newsletter JID
+ * @param {string|number} serverId Server ID of message
+ * @param {string} [reaction] Emoji string to react, or empty string to remove reaction
+ */
+export async function newsletterReact(sock, jid, serverId, reaction = '') {
+    return await sock.newsletterReactMessage(jid, serverId.toString(), reaction);
+}
+
+/**
+ * Fetch and decode clean messages from a WhatsApp Channel
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Newsletter JID
+ * @param {number} [count=20] Number of messages to retrieve
+ * @param {number} [since] Optional timestamp filter
+ * @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');
+
+    const result = [];
+    if (!messageContainers) return result;
+
+    for (const container of messageContainers) {
+        const msgNodes = getBinaryNodeChildren(container, 'message');
+        for (const m of msgNodes) {
+            const serverId = m.attrs?.server_id;
+            const messageId = m.attrs?.id;
+            const timestamp = m.attrs?.time ? parseInt(m.attrs.time, 10) : null;
+
+            // Extract views and reactions
+            const viewsNode = getBinaryNodeChild(m, 'views_count');
+            const viewsCount = viewsNode?.attrs?.count ? parseInt(viewsNode.attrs.count, 10) : 0;
+
+            const reactionsNode = getBinaryNodeChild(m, 'reactions');
+            const reactions = [];
+            if (reactionsNode) {
+                const reactionList = getBinaryNodeChildren(reactionsNode, 'reaction');
+                for (const r of reactionList) {
+                    reactions.push({
+                        emoji: r.attrs?.code,
+                        count: parseInt(r.attrs?.count || '0', 10)
+                    });
+                }
+            }
+
+            // Extract poll votes
+            const votesNode = getBinaryNodeChild(m, 'votes');
+            const pollVotes = [];
+            if (votesNode) {
+                const voteList = getBinaryNodeChildren(votesNode, 'vote');
+                for (const v of voteList) {
+                    const hashBuffer = v.content;
+                    pollVotes.push({
+                        count: parseInt(v.attrs?.count || '0', 10),
+                        optionHash: Buffer.isBuffer(hashBuffer) ? hashBuffer.toString('hex') : null
+                    });
+                }
+            }
+
+            // Extract protobuf message if available
+            const pTextNode = getBinaryNodeChild(m, 'plaintext');
+            let decodedMessage = null;
+            let text = null;
+            let mediaType = null;
+            let poll = null;
+
+            if (pTextNode && pTextNode.content) {
+                try {
+                    decodedMessage = proto.Message.decode(pTextNode.content);
+                    text = decodedMessage.conversation || 
+                           decodedMessage.extendedTextMessage?.text || 
+                           decodedMessage.imageMessage?.caption || 
+                           decodedMessage.videoMessage?.caption;
+
+                    if (decodedMessage.imageMessage) mediaType = 'image';
+                    else if (decodedMessage.videoMessage) mediaType = 'video';
+                    else if (decodedMessage.audioMessage) mediaType = 'audio';
+                    else if (decodedMessage.documentMessage) mediaType = 'document';
+
+                    const pollMsg = decodedMessage.pollCreationMessage || 
+                                    decodedMessage.pollCreationMessageV2 || 
+                                    decodedMessage.pollCreationMessageV3;
+
+                    if (pollMsg) {
+                        mediaType = 'poll';
+                        poll = {
+                            name: pollMsg.name,
+                            options: (pollMsg.options || []).map(o => ({
+                                name: o.optionName,
+                                hash: crypto.createHash('sha256').update(o.optionName || '').digest('hex')
+                            })),
+                            selectableCount: pollMsg.selectableOptionsCount || 1,
+                            votes: pollVotes
+                        };
+                    }
+                } catch (e) {}
+            }
+
+            result.push({
+                serverId,
+                messageId,
+                timestamp,
+                mediaType: mediaType || (pollVotes.length > 0 ? 'poll' : 'text'),
+                text,
+                poll,
+                viewsCount,
+                reactions,
+                rawProto: decodedMessage
+            });
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Search public WhatsApp Channels via directory
+ * @param {any} sock Baileys socket instance
+ * @param {string} query Search keyword
+ */
+export async function newsletterSearch(sock, query) {
+    if (!query) throw new Error('Search query is required');
+    const result = await sock.query({
+        tag: 'iq',
+        attrs: {
+            id: sock.generateMessageTag(),
+            type: 'get',
+            xmlns: 'newsletter',
+            to: 's.whatsapp.net'
+        },
+        content: [
+            {
+                tag: 'search',
+                attrs: { query }
+            }
+        ]
+    }).catch(async () => {
+        // Fallback to metadata lookup if query is an invite code
+        return await sock.newsletterMetadata('invite', query);
+    });
+    return result;
+}
+
+/**
+ * Fetch list of followed / joined newsletters
+ * @param {any} sock Baileys socket instance
+ */
+export async function newsletterList(sock) {
+    try {
+        const result = await sock.query({
+            tag: 'iq',
+            attrs: {
+                id: sock.generateMessageTag(),
+                type: 'get',
+                xmlns: 'newsletter',
+                to: 's.whatsapp.net'
+            },
+            content: [{ tag: 'subscribed', attrs: {} }]
+        });
+        return result;
+    } catch (e) {
+        return [];
+    }
+}
+
+/**
+ * Smart Channel (Newsletter) Poll Vote
+ * Automatically resolves channel links, quoted messages, message IDs, and option indexes.
+ *
+ * @param {any} sock Baileys socket instance
+ * @param {string|object} target Channel URL, JID, or quoted message/contextInfo
+ * @param {string|number} option Option text or 1-based index (e.g. 1, 2)
+ * @param {string|number} [explicitServerId] Optional explicit message server ID
+ */
+export async function channelVote(sock, target, option, explicitServerId = null) {
+    if (!sock) throw new Error('Socket instance is required');
+    if (!target) throw new Error('Target (link, JID, or quoted message) is required');
+    if (option === undefined || option === null || option === '') {
+        throw new Error('Option or option number to vote for is required');
+    }
+
+    let jid = null;
+    let serverId = explicitServerId ? explicitServerId.toString() : null;
+    let pollOptions = null;
+
+    // Case 1: Target is an object (quoted message or contextInfo)
+    if (typeof target === 'object') {
+        const ctx = target.extendedTextMessage?.contextInfo || target.contextInfo || target;
+
+        // Try to get newsletter JID
+        if (ctx.forwardedNewsletterMessageInfo?.newsletterJid) {
+            jid = ctx.forwardedNewsletterMessageInfo.newsletterJid;
+            if (ctx.forwardedNewsletterMessageInfo.serverMessageId) {
+                serverId = ctx.forwardedNewsletterMessageInfo.serverMessageId.toString();
+            }
+        } else if (ctx.remoteJid?.endsWith('@newsletter')) {
+            jid = ctx.remoteJid;
+        } else if (ctx.participant?.endsWith('@newsletter')) {
+            jid = ctx.participant;
+        }
+
+        if (!serverId && (ctx.stanzaId || ctx.server_id || ctx.serverId)) {
+            serverId = (ctx.server_id || ctx.serverId || ctx.stanzaId).toString();
+        }
+
+        // Try to extract poll options from quoted message
+        const qm = ctx.quotedMessage || target.message;
+        const pollMsg = qm?.pollCreationMessage || qm?.pollCreationMessageV2 || qm?.pollCreationMessageV3;
+        if (pollMsg?.options?.length) {
+            pollOptions = pollMsg.options.map((o) => o.optionName);
+        }
+    } else if (typeof target === 'string') {
+        const trimmed = target.trim();
+        // Check for WhatsApp Channel link (e.g. https://whatsapp.com/channel/0029Va84sN7J93wUd3cWwX2c/123)
+        const channelLinkMatch = trimmed.match(/whatsapp\.com\/channel\/([a-zA-Z0-9_-]+)(?:\/(\d+))?/i);
+        if (channelLinkMatch) {
+            const inviteCode = channelLinkMatch[1];
+            const urlServerId = channelLinkMatch[2];
+            if (urlServerId) serverId = urlServerId;
+
+            // Resolve invite code to newsletter metadata
+            try {
+                const meta = await sock.newsletterMetadata('invite', inviteCode);
+                jid = meta?.id || meta?.jid;
+            } catch (err) {
+                throw new Error(`Could not resolve channel invite "${inviteCode}": ${err.message}`);
+            }
+        } else if (trimmed.endsWith('@newsletter')) {
+            jid = trimmed;
+        }
+    }
+
+    if (!jid) {
+        throw new Error('Could not determine Channel (Newsletter) JID from target.');
+    }
+
+    // If serverId or pollOptions is missing, attempt to fetch recent messages to locate the poll
+    if (!serverId || !pollOptions) {
+        try {
+            const recent = await newsletterGetMessages(sock, jid, 25);
+            const targetPoll = serverId
+                ? recent.find((m) => m.serverId?.toString() === serverId && (m.mediaType === 'poll' || m.poll)) ||
+                  recent.find((m) => m.serverId?.toString() === serverId)
+                : recent.find((m) => m.mediaType === 'poll' || m.poll);
+            if (targetPoll) {
+                if (!serverId) serverId = targetPoll.serverId?.toString();
+                if (targetPoll.poll?.options?.length) {
+                    pollOptions = targetPoll.poll.options.map((o) => o.name);
+                }
+            }
+        } catch {}
+    }
+
+    if (!serverId) {
+        throw new Error('Could not find poll message server ID in this channel.');
+    }
+
+    // Map numeric index (1, 2...), single letter (A, B, C...), or match case-insensitively
+    let selectedOptionText = String(option).trim();
+    if (pollOptions && pollOptions.length > 0) {
+        if (/^\d+$/.test(selectedOptionText)) {
+            const idx = parseInt(selectedOptionText, 10) - 1;
+            if (idx >= 0 && idx < pollOptions.length) {
+                selectedOptionText = pollOptions[idx];
+            }
+        } else if (/^[a-zA-Z]$/.test(selectedOptionText)) {
+            const letterIdx = selectedOptionText.toUpperCase().charCodeAt(0) - 65;
+            const exactLetterMatch = pollOptions.find((o) => o.trim().toUpperCase() === selectedOptionText.toUpperCase());
+            if (exactLetterMatch) {
+                selectedOptionText = exactLetterMatch;
+            } else if (letterIdx >= 0 && letterIdx < pollOptions.length) {
+                selectedOptionText = pollOptions[letterIdx];
+            }
+        } else {
+            const matched = pollOptions.find((o) => o.toLowerCase() === selectedOptionText.toLowerCase());
+            if (matched) selectedOptionText = matched;
+        }
+    }
+
+    // Cast the vote
+    const voteResult = await newsletterVoteMessage(sock, jid, serverId, selectedOptionText);
+    return {
+        ...voteResult,
+        channelJid: jid,
+        serverId,
+        selectedOption: selectedOptionText,
+        option: selectedOptionText
+    };
+}
+

package/lib/Pro/polls.js

@@ -0,0 +1,214 @@
+import crypto from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { getAggregateVotesInPollMessage } from '../Utils/messages.js';
+
+/**
+ * High-level Pro Polls API for chama-bailez-pro
+ * Supports creating polls and voting in both E2EE chats/groups and WhatsApp Channels (Newsletters).
+ */
+
+/**
+ * Send a poll to a user, group, or channel
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target chat, group, or channel JID
+ * @param {{ name: string, values: string[], selectableCount?: number, toNewsletter?: boolean }} pollData 
+ */
+export async function sendPoll(sock, jid, pollData) {
+    if (!pollData || !pollData.name || !Array.isArray(pollData.values) || pollData.values.length < 2) {
+        throw new Error('Poll requires a name (question) and at least 2 option values.');
+    }
+
+    const selectableCount = pollData.selectableCount || 1;
+
+    // Direct channel poll formatting
+    if (jid.endsWith('@newsletter') || pollData.toNewsletter) {
+        const options = pollData.values.map(val => ({ optionName: val }));
+        return await sock.sendMessage(jid, {
+            poll: {
+                name: pollData.name,
+                values: pollData.values,
+                selectableCount
+            }
+        });
+    }
+
+    // Standard individual or group chat poll
+    return await sock.sendMessage(jid, {
+        poll: {
+            name: pollData.name,
+            values: pollData.values,
+            selectableCount
+        }
+    });
+}
+
+/**
+ * Programmatically cast a vote on a poll
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target chat, group, or channel JID
+ * @param {any} pollKeyOrMsg Poll creation message key or message object or serverId
+ * @param {string[]|string} selectedOptions Array of option strings or single option string
+ */
+export async function sendPollVote(sock, jid, pollKeyOrMsg, selectedOptions) {
+    const optionsArray = Array.isArray(selectedOptions) ? selectedOptions : [selectedOptions];
+    if (!optionsArray.length) {
+        throw new Error('Must specify at least one option to vote for.');
+    }
+
+    // 1. Channel (Newsletter) Poll Vote
+    if (jid.endsWith('@newsletter')) {
+        let serverId = null;
+        if (typeof pollKeyOrMsg === 'string' || typeof pollKeyOrMsg === 'number') {
+            serverId = pollKeyOrMsg.toString();
+        } else if (pollKeyOrMsg?.server_id || pollKeyOrMsg?.newsletterServerId || pollKeyOrMsg?.serverId) {
+            serverId = (pollKeyOrMsg.server_id || pollKeyOrMsg.newsletterServerId || pollKeyOrMsg.serverId).toString();
+        } else if (pollKeyOrMsg?.key?.server_id || pollKeyOrMsg?.key?.id) {
+            serverId = (pollKeyOrMsg.key.server_id || pollKeyOrMsg.key.id).toString();
+        }
+
+        if (!serverId) {
+            throw new Error('Server ID is required to vote on a newsletter poll.');
+        }
+
+        const primaryOption = optionsArray[0];
+        const optionHash = crypto.createHash('sha256').update(primaryOption).digest();
+        const optionHashHex = optionHash.toString('hex');
+
+        // Relay channel poll update message
+        const channelPollUpdateMsg = {
+            pollUpdateMessage: {
+                pollCreationMessageKey: {
+                    remoteJid: jid,
+                    id: serverId,
+                    fromMe: false
+                },
+                senderTimestampMs: Date.now()
+            }
+        };
+
+        const relayResult = await sock.relayMessage(jid, channelPollUpdateMsg, {
+            additionalAttributes: {
+                server_id: serverId
+            }
+        });
+
+        // Also query standard stanza
+        try {
+            await sock.query({
+                tag: 'message',
+                attrs: {
+                    to: jid,
+                    type: 'poll',
+                    server_id: serverId,
+                    id: sock.generateMessageTag()
+                },
+                content: [
+                    {
+                        tag: 'poll_vote',
+                        attrs: {
+                            option: optionHashHex
+                        }
+                    }
+                ]
+            }).catch(() => {});
+        } catch (e) {}
+
+        return {
+            success: true,
+            type: 'newsletter',
+            serverId,
+            option: primaryOption,
+            optionHashHex,
+            relayResult
+        };
+    }
+
+    // 2. Standard E2EE Chat / Group Poll Vote
+    let pollCreation = null;
+    let pollMsgId = null;
+    let pollCreatorJid = null;
+    let fromMe = false;
+
+    if (pollKeyOrMsg?.message) {
+        // Full message passed
+        pollCreation = pollKeyOrMsg.message.pollCreationMessage || 
+                       pollKeyOrMsg.message.pollCreationMessageV2 || 
+                       pollKeyOrMsg.message.pollCreationMessageV3;
+        pollMsgId = pollKeyOrMsg.key?.id;
+        pollCreatorJid = pollKeyOrMsg.key?.participant || pollKeyOrMsg.key?.remoteJid;
+        fromMe = pollKeyOrMsg.key?.fromMe || false;
+    } else if (pollKeyOrMsg?.id) {
+        // Message key passed
+        pollMsgId = pollKeyOrMsg.id;
+        pollCreatorJid = pollKeyOrMsg.participant || pollKeyOrMsg.remoteJid;
+        fromMe = pollKeyOrMsg.fromMe || false;
+    }
+
+    if (!pollMsgId) {
+        throw new Error('Invalid poll key or message provided. Could not determine poll message ID.');
+    }
+
+    const voterJid = sock.user?.id?.split(':')[0] + '@s.whatsapp.net';
+    const selectedOptionHashes = optionsArray.map(opt => crypto.createHash('sha256').update(opt).digest());
+
+    let encPayload = null;
+    let encIv = null;
+
+    if (pollCreation && pollCreation.encKey) {
+        const sign = Buffer.concat([
+            Buffer.from(pollMsgId),
+            Buffer.from(pollCreatorJid || jid),
+            Buffer.from(voterJid),
+            Buffer.from('Poll Vote'),
+            new Uint8Array([1])
+        ]);
+        const key0 = crypto.createHmac('sha256', new Uint8Array(32)).update(pollCreation.encKey).digest();
+        const encKey = crypto.createHmac('sha256', key0).update(sign).digest();
+        const aad = Buffer.from(`${pollMsgId}\u0000${voterJid}`);
+        encIv = crypto.randomBytes(12);
+
+        const voteMsgBytes = proto.Message.PollVoteMessage.encode({
+            selectedOptions: selectedOptionHashes
+        }).finish();
+
+        const cipher = crypto.createCipheriv('aes-256-gcm', encKey, encIv);
+        cipher.setAAD(aad);
+        const ct = cipher.update(voteMsgBytes);
+        const final = cipher.final();
+        const tag = cipher.getAuthTag();
+        encPayload = Buffer.concat([ct, final, tag]);
+    }
+
+    const pollUpdateMessage = {
+        pollCreationMessageKey: {
+            remoteJid: jid,
+            id: pollMsgId,
+            fromMe,
+            participant: pollCreatorJid
+        },
+        vote: encPayload ? {
+            encPayload,
+            encIv
+        } : undefined,
+        senderTimestampMs: Date.now()
+    };
+
+    const relayRes = await sock.relayMessage(jid, { pollUpdateMessage }, {});
+    return {
+        success: true,
+        type: 'e2ee',
+        pollMsgId,
+        votedOptions: optionsArray,
+        relayResult: relayRes
+    };
+}
+
+/**
+ * Get aggregate vote counts and voter list from a poll message
+ * @param {any} sock Baileys socket instance
+ * @param {any} pollMessage The stored poll message object containing reactions/pollUpdates
+ */
+export function getAggregatePollVotes(sock, pollMessage) {
+    if (!pollMessage) return [];
+    return getAggregateVotesInPollMessage(pollMessage, sock.user?.id);
+}

package/lib/Pro/profile.js

@@ -0,0 +1,100 @@
+/**
+ * High-level Pro Profile & Contact API for chama-bailez-pro
+ */
+
+/**
+ * Check if a phone number is registered on WhatsApp
+ * @param {any} sock Baileys socket instance
+ * @param {string} phoneNumber Phone number string
+ */
+export async function checkNumber(sock, phoneNumber) {
+    const cleaned = phoneNumber.replace(/[^0-9]/g, '');
+    const results = await sock.onWhatsApp(cleaned);
+    const first = results?.[0];
+    if (first && first.exists) {
+        return {
+            exists: true,
+            jid: first.jid,
+            number: cleaned,
+            formatted: `+${cleaned}`
+        };
+    }
+    return {
+        exists: false,
+        number: cleaned,
+        formatted: `+${cleaned}`
+    };
+}
+
+/**
+ * Update WhatsApp "About" / Bio status
+ * @param {any} sock Baileys socket instance
+ * @param {string} text Status bio text
+ */
+export async function setBio(sock, text) {
+    return await sock.updateProfileStatus(text);
+}
+
+/**
+ * Update display profile name
+ * @param {any} sock Baileys socket instance
+ * @param {string} name New display name
+ */
+export async function updateProfileName(sock, name) {
+    return await sock.updateProfileName(name);
+}
+
+/**
+ * Set profile picture for bot or a group
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target group JID or 'me'
+ * @param {Buffer|{ url: string }} content Image Buffer or URL
+ */
+export async function setProfilePicture(sock, jid, content) {
+    const targetJid = (!jid || jid === 'me') 
+        ? sock.user?.id?.split(':')[0] + '@s.whatsapp.net' 
+        : jid;
+    return await sock.updateProfilePicture(targetJid, content);
+}
+
+/**
+ * Remove profile picture for bot or group
+ * @param {any} sock Baileys socket instance
+ * @param {string} jid Target group JID or 'me'
+ */
+export async function removeProfilePicture(sock, jid) {
+    const targetJid = (!jid || jid === 'me') 
+        ? sock.user?.id?.split(':')[0] + '@s.whatsapp.net' 
+        : jid;
+    return await sock.removeProfilePicture(targetJid);
+}
+
+/**
+ * Reject an incoming WhatsApp call cleanly
+ * @param {any} sock Baileys socket instance
+ * @param {string} callId ID of the incoming call
+ * @param {string} callFrom Caller JID
+ */
+export async function rejectCall(sock, callId, callFrom) {
+    if (typeof sock.rejectCall === 'function') {
+        return await sock.rejectCall(callId, callFrom);
+    }
+    return await sock.query({
+        tag: 'call',
+        attrs: {
+            from: sock.user?.id,
+            to: callFrom
+        },
+        content: [
+            {
+                tag: 'reject',
+                attrs: {
+                    'call-id': callId,
+                    'call-creator': callFrom,
+                    count: '0'
+                },
+                content: undefined
+            }
+        ]
+    });
+}

package/lib/Pro/status.js

@@ -0,0 +1,76 @@
+/**
+ * High-level Pro WhatsApp Status (Stories) API for chama-bailez-pro
+ */
+
+function hexToArgb(hex) {
+    if (!hex) return 0xFF25D366; // Default WhatsApp Green
+    let cleanHex = hex.replace('#', '');
+    if (cleanHex.length === 6) {
+        cleanHex = 'FF' + cleanHex;
+    }
+    return parseInt(cleanHex, 16);
+}
+
+/**
+ * Send a text status (story) to WhatsApp broadcast
+ * @param {any} sock Baileys socket instance
+ * @param {string} text Text content of status
+ * @param {{ backgroundColor?: string|number, font?: number, statusJidList?: string[], allContacts?: boolean }} [options] 
+ */
+export async function sendStatusText(sock, text, options = {}) {
+    if (!text) throw new Error('Status text cannot be empty');
+
+    const backgroundColor = options.backgroundColor || '#25D366';
+    const font = options.font || 1; // 1: SERIF, 2: NORICAN, 3: BRYNDAN_WRITE, 4: BEBASNEUE, 5: OSWALD
+
+    return await sock.sendMessage('status@broadcast', { text }, {
+        backgroundColor,
+        font,
+        statusJidList: options.statusJidList
+    });
+}
+
+/**
+ * Send an image or video status (story) to WhatsApp broadcast
+ * @param {any} sock Baileys socket instance
+ * @param {Buffer|string|{ url: string }} media Buffer, local path, or URL
+ * @param {{ type?: 'image' | 'video', caption?: string, statusJidList?: string[] }} [options]
+ */
+export async function sendStatusMedia(sock, media, options = {}) {
+    const isVideo = options.type === 'video' || (typeof media === 'string' && /\.(mp4|mov|mkv)$/i.test(media));
+    const mediaContent = isVideo ? { video: media, caption: options.caption } : { image: media, caption: options.caption };
+
+    return await sock.sendMessage('status@broadcast', mediaContent, {
+        statusJidList: options.statusJidList
+    });
+}
+
+/**
+ * Mark a contact's status story as read (viewed)
+ * @param {any} sock Baileys socket instance
+ * @param {any} key Message key of the status ({ id, remoteJid, participant })
+ */
+export async function readStatus(sock, key) {
+    if (!key) throw new Error('Status key is required to mark as viewed');
+    return await sock.readMessages([key]);
+}
+
+/**
+ * Like or react with an emoji to a contact's status story
+ * @param {any} sock Baileys socket instance
+ * @param {any} key Message key of the status
+ * @param {string} [emoji='💚'] Emoji to react with
+ */
+export async function reactStatus(sock, key, emoji = '💚') {
+    if (!key) throw new Error('Status key is required to react');
+    const targetParticipant = key.participant || key.remoteJid;
+
+    return await sock.sendMessage('status@broadcast', {
+        react: {
+            text: emoji,
+            key
+        }
+    }, {
+        statusJidList: [targetParticipant]
+    });
+}

package/lib/index.js

@@ -1,6 +1,7 @@
 import makeWASocket from './Socket/index.js';
 import chalk from "chalk";
 import { enableCallAutoAnswer, getActiveVoipClient, CallState } from './Caller/auto-answer.js';
+import { attachProMethods } from './Pro/index.js';
 
 // === BANNER ASCII SMD — ishu-md ===
 console.log(chalk.hex("#FFC72C")("     ╦  ╦┌─┐┬ ┬┌─┐┬┌─ "));
@@ -34,6 +35,7 @@ export * from './Store/index.js';
 export * from './Socket/ban-checker.js';
 export * from './Games/index.js';
 export * from './Caller/index.mjs';
-export { enableCallAutoAnswer, getActiveVoipClient, CallState, makeWASocket };
+export * from './Pro/index.js';
+export { enableCallAutoAnswer, getActiveVoipClient, CallState, attachProMethods, makeWASocket };
 export default makeWASocket;
 //# sourceMappingURL=index.js.map

package/package.json

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