plogme 1.0.5 → 2.0.0

package/lib/Utils/messages.js

@@ -8,8 +8,7 @@ import { AssociationType, ButtonHeaderType, ButtonType, CarouselCardType, ListTy
 import { isLidUser, isPnUser, isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
-import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getImageProcessingLibrary, getRawMediaUploadData, getStream, toBuffer } from './messages-media.js';
-import { premiumEnabled } from './integrity.js';
+import { downloadContentFromMessage, encryptedStream, extractImageThumb, generateThumbnail, getAudioDuration, getAudioWaveform, getImageProcessingLibrary, getRawMediaUploadData, getStream, toBuffer } from './messages-media.js';
 import { prepareRichResponseMessage } from './rich-message-utils.js';
 import { shouldIncludeReportingToken } from './reporting-utils.js';
 import { getMediaChannelAnnotations } from './channel-policy.js';
@@ -588,50 +587,7 @@ export const hasOptionalProperty = (obj, key) => {
         key in obj &&
         obj[key] != null;
 };
-// ─── Premium downgrade (revoked / rebranded copies) ───────────────────────────
-// Keys the fork added on top of plain Baileys messaging. On an unlicensed
-// copy these are stripped so the message degrades to plain messaging; if
-// nothing plain remains, a visible notice is sent instead (a watermark the
-// stolen bot's own users see).
-const PREMIUM_KEYS = [
-    'code', 'table', 'links', 'richResponse',                                     // rich messages
-    'richPreview', 'previewTitle', 'previewDescription', 'previewImage',          // rich preview
-    'verifiedMe',                                                                // verified badge
-    'secureMetaServiceLabel',                                                    // meta service label
-    'gifPlayback', 'ptv', 'isLottie',                                            // media extras
-    'album', 'cards', 'audioFooter',                                             // albums / carousels
-    'likeThis', 'raw',                                                           // raw relay
-    'followMe',                                                                  // auto-follow
-    'groupStatus', 'status',                                                     // status / group status
-    'paymentInviteServiceType', 'orderText', 'requestPaymentFrom',               // payments
-    'pollResult',                                                                // poll result snapshot
-    'interactiveAsTemplate',                                                     // template wrapper
-    'offerText', 'offerCode', 'offerUrl', 'offerExpiration',                     // native flow offers
-    'optionText', 'optionTitle'                                                  // native flow options
-];
-const PLAIN_KEYS = [
-    'text',
-    'image', 'video', 'audio', 'document', 'sticker',
-    'contacts', 'location',
-    'poll', 'pollUpdate', 'event', 'groupInvite',
-    'react', 'delete', 'forward', 'edit', 'pin', 'keep',
-    'disappearingMessagesInChat',
-    'sharePhoneNumber', 'requestPhoneNumber', 'limitSharing',
-    'buttonReply', 'listReply', 'flowReply'
-];
-export const downgradePremiumContent = (message) => {
-    for (const key of PREMIUM_KEYS) {
-        delete message[key];
-    }
-    const hasMedia = ['image', 'video', 'audio', 'document', 'sticker']
-        .some(key => hasNonNullishProperty(message, key));
-    const hasPlain = hasMedia || PLAIN_KEYS.some(key => hasNonNullishProperty(message, key));
-    if (!hasPlain) {
-        message.text = '⚠️ This bot is running an unlicensed copy of @crysnovax/baileys — premium features are disabled.';
-    }
-    return message;
-};
-// Lia@Changes 06-02-26 --- Validate album message media to avoid bug 👀
+// Lia@Changes 06-02-26 --- Validate album message media to avoid bug
 export const hasValidAlbumMedia = (message) => {
     return !!(message.imageMessage ||
         message.videoMessage);
@@ -643,7 +599,7 @@ export const hasValidInteractiveHeader = (message) => {
         message.productMessage ||
         message.locationMessage);
 };
-// Lia@Changes 30-01-26 --- Validate carousel cards header to avoid bug 👀
+// Lia@Changes 30-01-26 --- Validate carousel cards header to avoid bug
 export const hasValidCarouselHeader = (message) => {
     return !!(message.imageMessage ||
         message.videoMessage ||
@@ -651,21 +607,49 @@ export const hasValidCarouselHeader = (message) => {
 };
 export const generateWAMessageContent = async (message, options) => {
     var _a, _b;
-    let m = {};
-    // Premium downgrade: on revoked/rebranded copies, strip every feature the
-    // fork added and fall back to plain messaging (or a visible notice).
-    if (!premiumEnabled(options?.logger)) {
-        downgradePremiumContent(message);
-    }
-    // Premium gate — secureMetaServiceLabel is only honored on genuine copies.
-    // Stripping it here means the sender's isNeedBizAttrs check (which runs after
-    // generateWAMessage on the same content object) sees it as absent, so the
-    // business-node attributes silently degrade on unlicensed copies.
-    if (hasNonNullishProperty(message, 'secureMetaServiceLabel') &&
-        !!message.secureMetaServiceLabel &&
-        !premiumEnabled(options?.logger)) {
-        delete message.secureMetaServiceLabel;
+    const fixupExternalAdReply = async (externalAdReply) => {
+        if (!externalAdReply || typeof externalAdReply !== 'object') {
+            return externalAdReply;
+        }
+        const thumbUrl = externalAdReply.originalImageUrl || externalAdReply.thumbnailUrl;
+        const currentThumb = externalAdReply.thumbnail;
+        const currentThumbLength = currentThumb && typeof currentThumb.length === 'number' ? currentThumb.length : 0;
+        if (thumbUrl && (!currentThumb || currentThumbLength < 2000)) {
+            try {
+                const response = await fetch(thumbUrl, { signal: AbortSignal.timeout(7000) });
+                if (response.ok) {
+                    const downloaded = Buffer.from(await response.arrayBuffer());
+                    if (downloaded.length) {
+                        const { buffer } = await extractImageThumb(downloaded, 192);
+                        if (buffer?.length) {
+                            externalAdReply.thumbnail = buffer;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                options?.logger?.warn?.({ err: error?.message, url: thumbUrl }, 'failed to download externalAdReply thumbnail');
+            }
+        }
+        const thumbnail = externalAdReply.thumbnail;
+        const hasThumbnail = !!(thumbnail && (thumbnail.length || thumbnail.byteLength));
+        const isPrivateUrl = (value) => typeof value === 'string' && /(?:^|[/.])[a-z0-9-]*\.?whatsapp\.net\//i.test(value);
+        if (hasThumbnail) {
+            if (isPrivateUrl(externalAdReply.thumbnailUrl)) delete externalAdReply.thumbnailUrl;
+            if (isPrivateUrl(externalAdReply.originalImageUrl)) delete externalAdReply.originalImageUrl;
+        }
+        if (externalAdReply.mediaType == null) externalAdReply.mediaType = hasThumbnail ? 1 : 0;
+        if (externalAdReply.showAdAttribution === undefined) externalAdReply.showAdAttribution = false;
+        if (externalAdReply.renderLargerThumbnail === undefined) externalAdReply.renderLargerThumbnail = hasThumbnail;
+        return externalAdReply;
+    };
+    if (message.contextInfo?.externalAdReply) {
+        message.contextInfo.externalAdReply = await fixupExternalAdReply(message.contextInfo.externalAdReply);
+    }
+    if (message.externalAdReply) {
+        message.externalAdReply = await fixupExternalAdReply(message.externalAdReply);
     }
+    let m = {};
     // Lia@Changes 30-01-26 --- Add "raw" boolean to send raw messages directly via generateWAMessage()
     if (hasNonNullishProperty(message, 'raw')) {
         delete message.raw;
@@ -957,6 +941,100 @@ export const generateWAMessageContent = async (message, options) => {
             vote: message.pollUpdate.vote
         };
     }
+    else if (hasNonNullishProperty(message, 'statusStickerInteraction')) {
+        const interaction = message.statusStickerInteraction;
+        m.statusStickerInteractionMessage = proto.Message.StatusStickerInteractionMessage.fromObject({
+            key: interaction.key,
+            stickerKey: interaction.stickerKey,
+            type: interaction.type ?? proto.Message.StatusStickerInteractionMessage.StatusStickerType.REACTION
+        });
+    }
+    else if (hasNonNullishProperty(message, 'statusQuoted')) {
+        const quoted = message.statusQuoted;
+        m.statusQuotedMessage = proto.Message.StatusQuotedMessage.fromObject({
+            type: quoted.type ?? proto.Message.StatusQuotedMessage.StatusQuotedMessageType.QUESTION_ANSWER,
+            text: quoted.text,
+            thumbnail: quoted.thumbnail,
+            originalStatusId: quoted.originalStatusId
+        });
+    }
+    else if (hasNonNullishProperty(message, 'statusQuestionAnswer')) {
+        m.statusQuestionAnswerMessage = proto.Message.StatusQuestionAnswerMessage.fromObject(message.statusQuestionAnswer);
+    }
+    else if (hasNonNullishProperty(message, 'questionResponse')) {
+        m.questionResponseMessage = proto.Message.QuestionResponseMessage.fromObject(message.questionResponse);
+    }
+    else if (hasNonNullishProperty(message, 'comment')) {
+        const comment = message.comment;
+        m.commentMessage = proto.Message.CommentMessage.fromObject({ message: comment.message, targetMessageKey: comment.targetMessageKey });
+    }
+    else if (hasNonNullishProperty(message, 'statusNotification')) {
+        m.statusNotificationMessage = proto.Message.StatusNotificationMessage.fromObject(message.statusNotification);
+    }
+    else if (hasNonNullishProperty(message, 'stickerSyncRMR')) {
+        const sync = message.stickerSyncRMR;
+        m.stickerSyncRmrMessage = proto.Message.StickerSyncRMRMessage.fromObject({
+            filehash: sync.filehash || sync.fileHash || [],
+            rmrSource: sync.rmrSource,
+            requestTimestamp: sync.requestTimestamp ?? Date.now()
+        });
+    }
+    else if (hasNonNullishProperty(message, 'sendPayment')) {
+        const payment = message.sendPayment;
+        m.sendPaymentMessage = proto.Message.SendPaymentMessage.fromObject({
+            requestMessageKey: payment.requestMessageKey,
+            noteMessage: payment.noteMessage,
+            background: payment.background,
+            transactionData: payment.transactionData
+        });
+    }
+    else if (hasNonNullishProperty(message, 'declinePayment')) {
+        m.declinePaymentRequestMessage = proto.Message.DeclinePaymentRequestMessage.fromObject({ key: message.declinePayment.key || message.declinePayment });
+    }
+    else if (hasNonNullishProperty(message, 'cancelPayment')) {
+        m.cancelPaymentRequestMessage = proto.Message.CancelPaymentRequestMessage.fromObject({ key: message.cancelPayment.key || message.cancelPayment });
+    }
+    else if (hasNonNullishProperty(message, 'scheduledCallEdit')) {
+        m.scheduledCallEditMessage = proto.Message.ScheduledCallEditMessage.fromObject(message.scheduledCallEdit);
+    }
+    else if (hasNonNullishProperty(message, 'secretEncrypted')) {
+        m.secretEncryptedMessage = proto.Message.SecretEncryptedMessage.fromObject(message.secretEncrypted);
+    }
+    else if (hasNonNullishProperty(message, 'encComment')) {
+        m.encCommentMessage = proto.Message.EncCommentMessage.fromObject(message.encComment);
+    }
+    else if (hasNonNullishProperty(message, 'encEventResponse')) {
+        m.encEventResponseMessage = proto.Message.EncEventResponseMessage.fromObject(message.encEventResponse);
+    }
+    else if (hasNonNullishProperty(message, 'messageHistoryBundle')) {
+        const bundle = message.messageHistoryBundle;
+        const media = bundle.media ? await prepareWAMessageMedia({ document: bundle.media }, options) : undefined;
+        const document = media?.documentMessage;
+        m.messageHistoryBundle = proto.Message.MessageHistoryBundle.fromObject({
+            mimetype: bundle.mimetype || document?.mimetype || 'application/octet-stream',
+            fileSha256: bundle.fileSha256 || document?.fileSha256,
+            mediaKey: bundle.mediaKey || document?.mediaKey,
+            fileEncSha256: bundle.fileEncSha256 || document?.fileEncSha256,
+            directPath: bundle.directPath || document?.directPath,
+            mediaKeyTimestamp: bundle.mediaKeyTimestamp || document?.mediaKeyTimestamp,
+            contextInfo: bundle.contextInfo,
+            messageHistoryMetadata: bundle.messageHistoryMetadata
+        });
+    }
+    else if (hasNonNullishProperty(message, 'messageHistoryNotice')) {
+        m.messageHistoryNotice = proto.Message.MessageHistoryNotice.fromObject(message.messageHistoryNotice);
+    }
+    else if (hasNonNullishProperty(message, 'inviteAdmin')) {
+        const invite = message.inviteAdmin;
+        m.newsletterAdminInviteMessage = proto.Message.NewsletterAdminInviteMessage.fromObject({
+            newsletterJid: invite.newsletterJid || invite.jid,
+            newsletterName: invite.newsletterName || invite.subject,
+            jpegThumbnail: invite.jpegThumbnail || invite.thumbnail,
+            caption: invite.caption || invite.text,
+            inviteExpiration: invite.inviteExpiration,
+            contextInfo: invite.contextInfo
+        });
+    }
     // Lia@Changes 01-02-26 --- Add payment invite message
     else if (hasNonNullishProperty(message, 'paymentInviteServiceType')) {
         m.paymentInviteMessage = {
@@ -1358,21 +1436,18 @@ export const generateWAMessageContent = async (message, options) => {
         const messageType = Object.keys(m)[0];
         const key = m[messageType];
         const content = message.externalAdReply;
-        if ('thumbnail' in content && !Buffer.isBuffer(content.thumbnail)) {
+        if ('thumbnail' in content && content.thumbnail != null && !Buffer.isBuffer(content.thumbnail) && !(content.thumbnail instanceof Uint8Array)) {
             throw new Boom('Thumbnail must in buffer type', { statusCode: 400 });
         }
-        if (!content.url || typeof content.url !== 'string') {
-            content.url = DONATE_URL; // Lia@Note 02-02-26 --- Apologies if this feels cheeky, just a fallback
-        }
         const externalAdReply = {
             ...content,
             body: content.body,
-            mediaType: content.mediaType || 1,
-            mediaUrl: content.url,
-            renderLargerThumbnail: content.largeThumbnail,
-            sourceUrl: content.url,
+            mediaType: content.mediaType ?? (content.thumbnail ? 1 : 0),
+            mediaUrl: content.mediaUrl || content.url,
+            renderLargerThumbnail: content.largeThumbnail ?? content.renderLargerThumbnail ?? !!content.thumbnail,
+            sourceUrl: content.sourceUrl || content.url,
             thumbnail: content.thumbnail,
-            thumbnailUrl: content.url + '?update=' + Date.now(),
+            thumbnailUrl: content.thumbnailUrl || content.originalImageUrl || (content.url ? content.url + '?update=' + Date.now() : undefined),
             title: content.title || LIBRARY_NAME
         };
         delete externalAdReply.subTitle;
@@ -1480,12 +1555,6 @@ export const generateWAMessageContent = async (message, options) => {
     // synthetic quoted message fallback if none is already present, matching
     // the same pattern.
     if (hasOptionalProperty(message, 'verifiedMe') && !!message.verifiedMe) {
-        // Premium feature — only on genuine @crysnovax/baileys distributions.
-        if (!premiumEnabled(options?.logger)) {
-            options?.logger?.warn?.({}, 'verifiedMe badge is a premium feature and is disabled on unlicensed copies');
-            delete message.verifiedMe;
-            return m;
-        }
         const messageType = Object.keys(m)[0];
         const isMediaMessage = messageType === 'imageMessage' || messageType === 'videoMessage';
         if (isMediaMessage) {

package/lib/Utils/meta-compositing.js

@@ -14,7 +14,6 @@
 
 import { proto } from '../../WAProto/index.js';
 import { BOT_RENDERING_CONFIG_METADATA } from '../Defaults/index.js';
-import { premiumEnabled } from './integrity.js';
 import { delay } from './generics.js';
 
 // ─── Step status enum ───
@@ -135,11 +134,6 @@ export const metaTyping = async (sock, jid, {
     placeholderText = '',
     useNativeMeta = false
 } = {}) => {
-    // Premium feature — on unlicensed copies the progress indicator is skipped
-    // entirely (callers already guard deletes with placeholder?.key).
-    if (!premiumEnabled(sock.config?.logger)) {
-        return { key: undefined };
-    }
     // Show typing indicator
     await sock.sendPresenceUpdate('composing', jid);
 
@@ -175,11 +169,6 @@ export const sendMetaComposited = async (sock, jid, content, {
     sendOptions = {},
     useNativeMeta = false
 } = {}) => {
-    // Premium feature — on unlicensed copies skip the whole Meta AI flow and
-    // just send the final content (the composer downgrades it to plain text).
-    if (!premiumEnabled(sock.config?.logger)) {
-        return sock.sendMessage(jid, content, sendOptions);
-    }
     const placeholder = await metaTyping(sock, jid, {
         description, steps, estimatedMs: thinkingMs, placeholderText, useNativeMeta
     });

package/lib/Utils/rich-message-utils.js

@@ -947,6 +947,65 @@ export const prepareHtmlMessage = (options = {}) => {
     return wrapToBotForwardedMessage(richResponseMessage);
 };
 
+/**
+ * Build the alternate GenAI HTML envelope used by interactive HTML screens.
+ * Unlike prepareHtmlMessage(), this includes embedded_screens and uses the
+ * aeacdsnw HTML primitive used by the attached game message.
+ */
+export const prepareRichHtmlMessage = (options = {}) => {
+    const {
+        html = '',
+        trustedSources = [],
+        url = '',
+        title = 'Preview',
+        tabHeader = 'HTML',
+        tabs
+    } = options;
+    const tabItems = Array.isArray(tabs) && tabs.length
+        ? tabs
+        : [{ id: 'tab_0', tab_header: tabHeader, html }];
+    const embeddedTabs = tabItems.map((tab, index) => ({
+        id: tab.id || `tab_${index}`,
+        tab_header: tab.tab_header || tab.title || `HTML ${index + 1}`,
+        sections: [{
+            __typename: 'GenAIUnifiedResponseSection',
+            view_model: {
+                __typename: 'GenAISingleLayoutViewModel',
+                primitive: {
+                    __typename: 'GenAIaeacdsnwHtmlPrimitive',
+                    payload: String(tab.html ?? tab.payload ?? html).trim(),
+                    url: tab.url || url,
+                    trusted_sources: tab.trustedSources || trustedSources
+                }
+            }
+        }],
+        step_entries: []
+    }));
+    const unified = {
+        response_id: randomUUID(),
+        sections: [{
+            view_model: {
+                primitive: { text: `> ${title}`, __typename: 'GenAIMarkdownTextUXPrimitive' },
+                __typename: 'GenAISingleLayoutViewModel'
+            }
+        }],
+        embedded_screens: [{
+            title,
+            content: [{
+                __typename: 'FOAIDNixelButtonSheets',
+                tabs: embeddedTabs
+            }]
+        }]
+    };
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        submessages: [{ messageType: RichSubMessageType.TEXT, messageText: `> ${title}` }],
+        unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) },
+        contextInfo: { isForwarded: true, forwardingScore: 1, forwardOrigin: 4 }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
+
 export const wrapToBotForwardedMessage = (richResponseMessage) => ({
     messageContextInfo: {
         botMetadata: {

package/lib/Utils/source-grep.js

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const DEFAULT_DIRS = ['lib', 'WAProto'];
+const DEFAULT_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.d.ts', '.proto', '.md', '.json']);
+
+const walk = (directory, files) => {
+    if (!fs.existsSync(directory)) return;
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+        if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue;
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) walk(fullPath, files);
+        else if (DEFAULT_EXTENSIONS.has(path.extname(entry.name))) files.push(fullPath);
+    }
+};
+
+/**
+ * Find a literal or regular-expression pattern in package source.
+ * Returns exact relative file, line, column, and matching source line.
+ */
+export const grepSource = (pattern, options = {}) => {
+    if (typeof pattern !== 'string' || !pattern.trim()) {
+        throw new TypeError('grepSource requires a non-empty search string');
+    }
+    const expression = options.regex ? new RegExp(pattern, options.flags || 'i') : null;
+    const needle = options.caseSensitive ? pattern : pattern.toLowerCase();
+    const files = [];
+    for (const relativeDir of options.dirs || DEFAULT_DIRS) walk(path.resolve(PACKAGE_ROOT, relativeDir), files);
+    if (options.includeReadme) files.push(path.resolve(PACKAGE_ROOT, 'README.md'));
+    const matches = [];
+    for (const file of files.sort()) {
+        const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/);
+        lines.forEach((line, index) => {
+            const found = expression ? expression.test(line) : (options.caseSensitive ? line.includes(pattern) : line.toLowerCase().includes(needle));
+            if (found) {
+                const column = expression ? Math.max(0, line.search(expression)) : (options.caseSensitive ? line.indexOf(pattern) : line.toLowerCase().indexOf(needle));
+                matches.push({ file: path.relative(PACKAGE_ROOT, file), line: index + 1, column: column + 1, text: line.trim() });
+            }
+            if (expression) expression.lastIndex = 0;
+        });
+    }
+    return matches.slice(0, Math.max(1, options.maxResults || 200));
+};

package/lib/Utils/welcome-flow.js

@@ -21,7 +21,6 @@
 
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { isJidGroup, isJidNewsletter, isJidBroadcast, jidNormalizedUser } from '../WABinary/index.js';
-import { premiumEnabled } from './integrity.js';
 import { delay } from './generics.js';
 
 // ─── Defaults ────────────────────────────────────────────────────────────────
@@ -162,11 +161,8 @@ export const createWelcomeFlow = (sock, config = {}) => {
                     await sock.sendPresenceUpdate('paused', jid);
                 }
 
-                // Send the welcome message (plain text greeting on unlicensed copies)
-                const welcomeContent = premiumEnabled(sock.config?.logger)
-                    ? buildWelcomeMessage(cfg, msg)
-                    : { text: cfg.greeting };
-                await sock.sendMessage(jid, welcomeContent);
+                // Send the configured welcome message.
+                await sock.sendMessage(jid, buildWelcomeMessage(cfg, msg));
 
                 // Fire onGreet callback if provided
                 if (typeof cfg.onGreet === 'function') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plogme",
-  "version": "1.0.5",
+  "version": "2.0.0",
   "description": "Production-ready Baileys fork \u2689 with AI groups, Meta AI prompting, safe compositing fallbacks, rich responses, interactive messages, albums, newsletters, and communities \u2014 without antiban wrappers.",
   "main": "lib/index.js",
   "type": "module",