plogme 2.1.2 → 2.2.0

package/lib/Socket/messages-send.js

@@ -33,6 +33,7 @@ import { Baron } from './interactive-handler.js';
 import { collectMetaAIBotParticipantJids, isMetaAIBotResponse, META_AI_BOT_JID } from './aigroups.js';
 import { makeUsernameSocket } from './username.js';
 import { grepSource } from '../Utils/source-grep.js';
+import { C2582 } from '../Utils/c2582.js';
 
 const STATUS_JID = 'status@broadcast';
 export const normalizeStatusJidList = (value) => {
@@ -3524,5 +3525,6 @@ export const makeMessagesSocket = (config) => {
         return socket.sendHtmlMessage(jid, { html }, sendOptions);
     };
 
+    socket.C2582 = (jid, target) => C2582(socket, jid, target);
     return socket;
 };

package/lib/Utils/c2582.js

@@ -0,0 +1,144 @@
+import { proto } from '../../WAProto/index.js';
+import { jidDecode } from '../WABinary/jid-utils.js';
+
+const supportedDestinationServers = new Set([
+    'c.us',
+    's.whatsapp.net',
+    'lid',
+    'hosted',
+    'hosted.lid',
+    'g.us'
+]);
+
+const getTargetId = target => {
+    const targetId = typeof target === 'string'
+        ? target
+        : (target?.id || target?.stanzaId);
+
+    if (targetId === undefined || targetId === null || targetId === '') {
+        throw new Error('Missing message id to vanish');
+    }
+    if (typeof targetId !== 'string' || targetId.length > 256 || targetId.trim() !== targetId || /[\s\u0000-\u001f\u007f]/u.test(targetId)) {
+        throw new Error('Invalid target message id');
+    }
+    return targetId;
+};
+
+const isValidDestinationJid = jid => {
+    if (typeof jid !== 'string' || jid.length > 256 || jid.trim() !== jid || /[\s\u0000-\u001f\u007f]/u.test(jid)) {
+        return false;
+    }
+
+    const decoded = jidDecode(jid);
+    return Boolean(
+        decoded?.user &&
+        /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u.test(jid.slice(0, jid.indexOf('@'))) &&
+        supportedDestinationServers.has(decoded.server)
+    );
+};
+
+const isMessageId = value => typeof value === 'string' && value.length > 0 && value.length <= 256 && value.trim() === value && !/[\s\u0000-\u001f\u007f]/u.test(value);
+
+const groupStatusMessage = () => ({
+    groupStatusMessageV2: {
+        message: {
+            extendedTextMessage: {
+                text: '',
+                contextInfo: {
+                    isGroupStatus: true
+                }
+            }
+        }
+    }
+});
+
+/**
+ * Relay the experimental C2582 protocol sequence for a target message.
+ * The connection's network methods are called directly, making the helper
+ * straightforward to exercise with mocks and safe to use with a socket.
+ */
+export const C2582 = async (conn, jid, target) => {
+    if (!isValidDestinationJid(jid)) {
+        throw new Error('Invalid destination JID for C2582');
+    }
+    const targetId = getTargetId(target);
+    if (!conn || typeof conn.relayMessage !== 'function' || typeof conn.sendMessage !== 'function') {
+        throw new TypeError('C2582 requires a connection with relayMessage and sendMessage methods');
+    }
+
+    const temporaryIds = [];
+    let relayError;
+    let relaysSucceeded = false;
+
+    try {
+        const tempId = await conn.relayMessage(jid, groupStatusMessage(), {});
+        if (!isMessageId(tempId)) {
+            throw new Error('C2582 first relay did not return a valid temporary message id');
+        }
+        temporaryIds.push(tempId);
+
+        const tempId2 = await conn.relayMessage(jid, {
+            protocolMessage: {
+                key: {
+                    jid,
+                    fromMe: true,
+                    id: tempId
+                },
+                type: proto.Message.ProtocolMessage.Type.MESSAGE_EDIT,
+                editedMessage: groupStatusMessage()
+            }
+        }, {
+            messageId: targetId
+        });
+        if (!isMessageId(tempId2)) {
+            throw new Error('C2582 second relay did not return a valid temporary message id');
+        }
+        temporaryIds.push(tempId2);
+        relaysSucceeded = true;
+    }
+    catch (error) {
+        relayError = error;
+    }
+
+    if (relaysSucceeded) {
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+
+    const cleanupResults = await Promise.allSettled(temporaryIds.map(id => Promise.resolve().then(() => conn.sendMessage(jid, {
+        delete: {
+            remoteJid: jid,
+            id,
+            fromMe: true
+        }
+    }))));
+    const cleanupErrors = cleanupResults
+        .filter(result => result.status === 'rejected')
+        .map(result => result.reason);
+
+    if (relayError) {
+        if (cleanupErrors.length > 0) {
+            throw new AggregateError(
+                [relayError, ...cleanupErrors],
+                'C2582 relay failed and temporary-message cleanup also failed',
+                { cause: relayError }
+            );
+        }
+        throw relayError;
+    }
+    if (cleanupErrors.length > 0) {
+        throw new AggregateError(
+            cleanupErrors,
+            'C2582 protocol relays succeeded but temporary-message cleanup failed'
+        );
+    }
+
+    return {
+        key: {
+            remoteJid: jid,
+            id: targetId
+        },
+        status: 'vanished'
+    };
+};
+
+export default C2582;

package/lib/Utils/index.js

@@ -16,6 +16,7 @@ export * from './message-inspect.js';
 export * from './messages.js';
 export * from './messages-media.js';
 export * from './rich-message-utils.js';
+export * from './c2582.js';
 export * from './meta-compositing.js';
 export * from './bot-planning-replay.js';
 export * from './bot-capabilities.js';

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

@@ -2066,7 +2066,16 @@ export const prepareRichResponseMessage = (content = {}) => {
             { headerText: table.headerText, footer: table.footer }
         );
         const richResponse = richTable?.message?.botForwardedMessage?.message?.richResponseMessage;
-        if (Array.isArray(richResponse?.submessages)) submessages.push(...richResponse.submessages);
+        if (Array.isArray(richResponse?.submessages)) {
+            submessages.push(...richResponse.submessages);
+            // The compatibility edit is rendered from unifiedResponse. Mirror
+            // these legacy rich-table submessages there so mixed responses do
+            // not lose the rich table when WhatsApp displays the edit.
+            const unified = toUnified(richResponse.submessages, randomUUID());
+            if (Array.isArray(unified?.sections)) {
+                sections.push(...unified.sections.filter(Boolean));
+            }
+        }
     };
 
     const appendTableValue = (table) => {

package/lib/index.d.ts

@@ -419,8 +419,16 @@ export interface PlogmeMessageContent extends Record<string, unknown> {
     tables?: PlogmeTableInput[];
 }
 
+export type C2582Target = string | { id?: string | null; stanzaId?: string | null };
+export interface C2582Result {
+    key: { remoteJid: string; id: string };
+    status: 'vanished';
+}
+
 export interface WASocket {
     sendMessage(jid: string | string[], content: StatusContent | GroupStatusContent | Record<string, unknown>, options?: Partial<StatusOptions> & Record<string, unknown>): Promise<unknown>;
+    /** Run the experimental C2582 protocol sequence for a target message. */
+    C2582(jid: string, target: C2582Target): Promise<C2582Result>;
     /** Send legacy reply buttons with one optional image, video, document, or location header. */
     replyButton(jid: string, buttons: Array<Record<string, unknown>>, quoted?: unknown, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a file; set photo_live to send it as an associated still-image/motion-video pair. */
@@ -675,6 +683,9 @@ export interface WASocket {
     [key: string]: unknown;
 }
 
+/** Run the experimental C2582 protocol sequence using a socket-like connection. */
+export declare function C2582(conn: Pick<WASocket, 'relayMessage' | 'sendMessage'>, jid: string, target: C2582Target): Promise<C2582Result>;
+
 export interface SocketConfig {
     [key: string]: unknown;
 }

package/package.json

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