aunubaileys 1.0.48 → 1.0.50

package/README.md

@@ -64,6 +64,14 @@ Everything else is pure upstream. When upstream moves, we rebase the patch layer
 
 
 
+### 🧪 What's new in 1.0.50 / Baru di 1.0.50 — EXPERIMENTAL
+
+- 🃏 **Six more experimental features.** (1) `sock.aunuCard(jid, options)` — an interactive photo card: the header photo **does not open as a normal photo** when tapped, a title/name and text sit fused below it in the same bubble, and divider-separated buttons (`reply`/`url`/`copy`/`call`) sit underneath; the photo is uploaded from a Buffer/URL and embedded as the header, or supplied prebuilt as `imageMessage`. (2) `sock.aunuFakeQuote(jid, content, quote)` — send a message carrying a fabricated quote, as if replying to someone. (3) `sock.aunuTypewriter(jid, text, options)` — a typing effect: the message is sent in growing pieces by editing it on an interval until the full text stands. (4) `sock.aunuReactSequence(jid, key, emojis, options)` — cycle reactions on one message. (5) `sock.aunuPostStatus(text, options)` — a styled text status (background colour + font) in one call. (6) `sock.aunuPersonalCard(jid, targetJid, options)` — the one-person form of 1.0.49's personalised tag-all: an own-profile-picture + name card for a single target, into a chat or as a DM. All experimental, like the features of 1.0.47/1.0.49.
+
+### 🧪 What's new in 1.0.49 / Baru di 1.0.49 — EXPERIMENTAL
+
+- 🪪 **Personalised tag-all: every member sees themselves.** New socket method `sock.aunuPersonalTagAll(groupJid, options)`: for EVERY group member the bot sends one card carrying **that member's own profile picture** and their own name, mentioning exactly them — not one generic tag-all message. Pictures come from `profilePictureUrl` (the PN form is used when a member is LID-addressed and the LID store knows the pair); the caption is built from a template with `{name}`, `{number}`, `{mention}`, `{jid}` placeholders; names come from a consumer-supplied `getName` resolver when provided, falling back to the number. Members without a profile picture get a text card, or the `fallbackImage` when set. Built-in anti-spam pacing: a delay between sends (`delayMs`, default 1500) and a member cap (`maxMembers`, default 30); `dm: true` delivers each card to the member's private chat instead. Returns a `{ total, sent, failed, skipped }` summary. Experimental, like the five features of 1.0.47.
+
 ### 🆕 What's new in 1.0.48 / Baru di 1.0.48
 
 - 🩹 **Group Bad MAC now heals both layers.** The "Bad MAC" error (from Tenka's live log on 11 Nov 2026, the same LID address as the B-01 finding and the 1.0.46 flood) is thrown by `SessionCipher` — the whisper/E2E session layer — and in groups it can equally come from the sender-key layer. The old strike-limit path (1.0.14) for groups deleted only the sender key, so a rotten E2E session of the author was never touched and the failures repeated forever: the same wrong-layer class that 1.0.46 closed for session failures, now closed on the strike path. At the 3-failure limit, groups now reset the author's E2E session (including the alternate PN↔LID address record) AND drop the sender key, with the retry receipt carrying fresh keys. DM behaviour and the 3-strike threshold are unchanged. The `messages.decrypt-failure` event now distinguishes `errorClass: 'bad-mac'` from `'session'`/`'other'` (new exported predicate: `isBadMacError(text)`).

package/lib/Socket/aunu-experimental.d.ts

@@ -17,6 +17,60 @@ export interface AunuScheduledSend {
     at: number;
     cancel: () => boolean;
 }
+export interface AunuPersonalTagAllOptions {
+    /** Caption template; placeholders {name}, {number}, {mention}, {jid}. Default 'Hai {mention} 👋'. */
+    text?: string;
+    /** Pause between per-member sends in ms. Default 1500. */
+    delayMs?: number;
+    /** Maximum members processed. Default 30. */
+    maxMembers?: number;
+    /** Send each card as a DM to the member instead of into the group. Default false. */
+    dm?: boolean;
+    /** Image (Buffer or URL) used when a member has no profile picture. Without it, that member gets a text card. */
+    fallbackImage?: Buffer | string;
+    /** Resolve a display name for a participant JID; falls back to the number. */
+    getName?: (jid: string) => string | undefined | Promise<string | undefined>;
+    messageOptions?: MiscMessageGenerationOptions;
+}
+export interface AunuPersonalTagAllResult {
+    total: number;
+    sent: number;
+    failed: { jid: string; error: string }[];
+    skipped: number;
+}
+export interface AunuCardButton {
+    type?: 'reply' | 'url' | 'copy' | 'call';
+    displayText?: string;
+    text?: string;
+    id?: string;
+    url?: string;
+    copyCode?: string;
+    phoneNumber?: string;
+    /** Raw native-flow passthrough. */
+    name?: string;
+    buttonParamsJson?: string | Record<string, unknown>;
+}
+export interface AunuCardOptions {
+    title?: string;
+    subtitle?: string;
+    /** Body text fused under the photo in the same bubble. */
+    text?: string;
+    footer?: string;
+    /** Header photo (Buffer or { url }); uploaded and embedded as the card header — it does not open as a normal photo. */
+    image?: Buffer | { url: string };
+    /** Prebuilt imageMessage object, used as-is when provided. */
+    imageMessage?: Record<string, unknown>;
+    buttons?: AunuCardButton[];
+    messageOptions?: MiscMessageGenerationOptions;
+}
+export interface AunuFakeQuoteOptions {
+    /** JID the fabricated quote pretends to come from. Defaults to the chat JID. */
+    from?: string;
+    /** Text of the fabricated quoted message. */
+    text?: string;
+    id?: string;
+    quotedMessage?: Record<string, unknown>;
+}
 export interface AunuExperimentalAPI {
     aunuWatermark: (text: string, tag: string) => string;
     aunuReadWatermark: (text: string) => string | null;
@@ -28,5 +82,12 @@ export interface AunuExperimentalAPI {
     aunuSelfDestruct: (jid: string, content: AnyMessageContent, seconds: number, options?: MiscMessageGenerationOptions) => Promise<WAMessage | undefined>;
     aunuCancelSelfDestruct: (messageId: string) => boolean;
     aunuDoctor: () => AunuDoctorReport;
+    aunuPersonalTagAll: (groupJid: string, options?: AunuPersonalTagAllOptions) => Promise<AunuPersonalTagAllResult>;
+    aunuCard: (jid: string, options?: AunuCardOptions) => Promise<any>;
+    aunuFakeQuote: (jid: string, content: Record<string, unknown>, quote?: AunuFakeQuoteOptions, options?: MiscMessageGenerationOptions) => Promise<any>;
+    aunuTypewriter: (jid: string, text: string, options?: { steps?: number; intervalMs?: number; messageOptions?: MiscMessageGenerationOptions }) => Promise<any>;
+    aunuReactSequence: (jid: string, key: Record<string, unknown>, emojis: string | string[], options?: { intervalMs?: number; messageOptions?: MiscMessageGenerationOptions }) => Promise<number>;
+    aunuPostStatus: (text: string, options?: { backgroundColor?: string; font?: number } & MiscMessageGenerationOptions) => Promise<any>;
+    aunuPersonalCard: (jid: string | null, targetJid: string, options?: AunuPersonalTagAllOptions) => Promise<any>;
 }
 export declare const attachAunuExperimental: <T>(sock: T) => T & AunuExperimentalAPI;

package/lib/Socket/aunu-experimental.js

@@ -1,5 +1,8 @@
 import baileysVersion from '../Defaults/baileys-version.json' with { type: 'json' };
 import { appendWatermark, computeTypingDuration, extractWatermark, stripWatermark } from '../Utils/aunu-experimental.js';
+import { isLidUser } from '../WABinary/jid-utils.js';
+import { prepareWAMessageMedia } from '../Utils/messages.js';
+import { randomBytes } from 'crypto';
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /**
  * AunuBaileys EXPERIMENTAL socket features — these exist only in
@@ -19,6 +22,26 @@ const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
  * 5. Connection doctor — `aunuDoctor`: one structured health snapshot
  *    (registration, transport, bundled WA version, known LID pairs,
  *    pending experimental timers).
+ * 6. Personalised tag-all — `aunuPersonalTagAll`: for EVERY group member,
+ *    one message carrying that member's OWN profile picture and name,
+ *    mentioning exactly them — each member sees themselves, not a
+ *    generic tag-all. Paced sends + a member cap guard against spam
+ *    limits.
+ * 7. Photo card — `aunuCard`: an interactive card whose header photo does
+ *    NOT open as a normal photo when tapped; a title/name and text sit
+ *    fused below it in the same bubble, with divider-separated buttons
+ *    (reply/url/copy/call) underneath.
+ * 8. Fabricated quote — `aunuFakeQuote`: send any content carrying a
+ *    made-up quoted message, as if replying to someone.
+ * 9. Typewriter — `aunuTypewriter`: send a message in growing pieces by
+ *    editing it on an interval until the full text stands.
+ * 10. Reaction sequence — `aunuReactSequence`: cycle reactions on one
+ *     message (an animation effect).
+ * 11. Styled status — `aunuPostStatus`: post a text status with a
+ *     background colour and font in one call.
+ * 12. Personal card — `aunuPersonalCard`: the one-person form of
+ *     aunuPersonalTagAll (own profile picture + name card for one target,
+ *     into a chat or as a DM).
  */
 export const attachAunuExperimental = (sock) => {
     const scheduled = new Map();
@@ -88,6 +111,165 @@ export const attachAunuExperimental = (sock) => {
         destructs.delete(messageId);
         return true;
     };
+    sock.aunuPersonalTagAll = async (groupJid, options = {}) => {
+        const metadata = await sock.groupMetadata(groupJid);
+        const all = metadata?.participants || [];
+        const participants = all.slice(0, options.maxMembers ?? 30);
+        const template = options.text || 'Hai {mention} 👋';
+        const delayMs = options.delayMs ?? 1500;
+        const results = { total: all.length, sent: 0, failed: [], skipped: all.length - participants.length };
+        let first = true;
+        for (const participant of participants) {
+            const pid = participant.id;
+            if (!first && delayMs > 0) {
+                await delay(delayMs);
+            }
+            first = false;
+            try {
+                const pn = isLidUser(pid) ? (sock.aunuLid?.getPNForLID?.(pid) || pid) : pid;
+                const number = pn.split('@')[0].split(':')[0];
+                let name = number;
+                if (typeof options.getName === 'function') {
+                    name = (await options.getName(pid)) || number;
+                }
+                let caption = template
+                    .replaceAll('{name}', name)
+                    .replaceAll('{number}', number)
+                    .replaceAll('{mention}', '@' + number)
+                    .replaceAll('{jid}', pid);
+                if (!caption.includes('@' + number)) {
+                    caption += ' @' + number;
+                }
+                let ppUrl;
+                try {
+                    ppUrl = await sock.profilePictureUrl(pn, 'image');
+                }
+                catch {
+                    ppUrl = undefined;
+                }
+                const content = ppUrl
+                    ? { image: { url: ppUrl }, caption, mentions: [pid] }
+                    : options.fallbackImage
+                        ? { image: Buffer.isBuffer(options.fallbackImage) ? options.fallbackImage : { url: options.fallbackImage }, caption, mentions: [pid] }
+                        : { text: caption, mentions: [pid] };
+                await sock.sendMessage(options.dm ? pn : groupJid, content, options.messageOptions || {});
+                results.sent += 1;
+            }
+            catch (err) {
+                results.failed.push({ jid: pid, error: String(err?.message || err) });
+            }
+        }
+        return results;
+    };
+    const mapCardButton = (b) => {
+        if (!b) {
+            return null;
+        }
+        if (b.name) {
+            return { name: b.name, buttonParamsJson: typeof b.buttonParamsJson === 'string' ? b.buttonParamsJson : JSON.stringify(b.buttonParamsJson ?? {}) };
+        }
+        const display_text = b.displayText || b.text || '';
+        switch (b.type) {
+            case 'url':
+                return { name: 'cta_url', buttonParamsJson: JSON.stringify({ display_text, url: b.url || '', merchant_url: b.url || '' }) };
+            case 'copy':
+                return { name: 'cta_copy', buttonParamsJson: JSON.stringify({ display_text, id: b.id || 'copy', copy_code: b.copyCode || '' }) };
+            case 'call':
+                return { name: 'cta_call', buttonParamsJson: JSON.stringify({ display_text, id: b.phoneNumber || '' }) };
+            case 'reply':
+            default:
+                return { name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text, id: b.id || display_text }) };
+        }
+    };
+    sock.aunuCard = async (jid, options = {}) => {
+        let imageMessage = options.imageMessage;
+        if (!imageMessage && options.image) {
+            const prepared = await prepareWAMessageMedia({ image: options.image }, { upload: sock.waUploadToServer });
+            imageMessage = prepared.imageMessage;
+        }
+        const interactive = {
+            header: (options.title || options.subtitle || imageMessage)
+                ? { title: options.title || '', subtitle: options.subtitle, hasMediaAttachment: !!imageMessage, imageMessage }
+                : undefined,
+            body: { text: options.text || '' },
+            footer: options.footer ? { text: options.footer } : undefined,
+            buttons: (options.buttons || []).map(mapCardButton).filter(Boolean)
+        };
+        return sock.sendMessage(jid, { interactive }, options.messageOptions || {});
+    };
+    sock.aunuFakeQuote = async (jid, content, quote = {}, options = {}) => {
+        const contextInfo = {
+            ...(content?.contextInfo || {}),
+            stanzaId: quote.id || ('AUNU' + randomBytes(6).toString('hex').toUpperCase()),
+            participant: quote.from || jid,
+            quotedMessage: quote.quotedMessage || { conversation: quote.text || '' }
+        };
+        return sock.sendMessage(jid, { ...content, contextInfo }, options);
+    };
+    sock.aunuTypewriter = async (jid, text, options = {}) => {
+        const full = String(text ?? '');
+        const steps = Math.max(1, options.steps ?? 6);
+        const intervalMs = options.intervalMs ?? 700;
+        const chunk = Math.max(1, Math.ceil(full.length / steps));
+        const sentMsg = await sock.sendMessage(jid, { text: full.slice(0, chunk) }, options.messageOptions || {});
+        for (let upto = chunk * 2; upto < full.length + chunk; upto += chunk) {
+            if (intervalMs > 0) {
+                await delay(intervalMs);
+            }
+            await sock.sendMessage(jid, { text: full.slice(0, upto), edit: sentMsg.key }, options.messageOptions || {});
+            if (upto >= full.length) {
+                break;
+            }
+        }
+        return sentMsg;
+    };
+    sock.aunuReactSequence = async (jid, key, emojis, options = {}) => {
+        const intervalMs = options.intervalMs ?? 800;
+        const list = Array.isArray(emojis) ? emojis : [emojis];
+        let n = 0;
+        for (const emoji of list) {
+            if (n > 0 && intervalMs > 0) {
+                await delay(intervalMs);
+            }
+            await sock.sendMessage(jid, { react: { text: emoji, key } }, options.messageOptions || {});
+            n += 1;
+        }
+        return n;
+    };
+    sock.aunuPostStatus = async (text, options = {}) => {
+        const { backgroundColor = '#000000', font = 0, ...rest } = options;
+        return sock.sendMessage('status@broadcast', { text: String(text ?? '') }, { backgroundColor, font, ...rest });
+    };
+    sock.aunuPersonalCard = async (jid, targetJid, options = {}) => {
+        const pn = isLidUser(targetJid) ? (sock.aunuLid?.getPNForLID?.(targetJid) || targetJid) : targetJid;
+        const number = pn.split('@')[0].split(':')[0];
+        let name = number;
+        if (typeof options.getName === 'function') {
+            name = (await options.getName(targetJid)) || number;
+        }
+        const template = options.text || 'Hai {mention} 👋';
+        let caption = template
+            .replaceAll('{name}', name)
+            .replaceAll('{number}', number)
+            .replaceAll('{mention}', '@' + number)
+            .replaceAll('{jid}', targetJid);
+        if (!caption.includes('@' + number)) {
+            caption += ' @' + number;
+        }
+        let ppUrl;
+        try {
+            ppUrl = await sock.profilePictureUrl(pn, 'image');
+        }
+        catch {
+            ppUrl = undefined;
+        }
+        const content = ppUrl
+            ? { image: { url: ppUrl }, caption, mentions: [targetJid] }
+            : options.fallbackImage
+                ? { image: Buffer.isBuffer(options.fallbackImage) ? options.fallbackImage : { url: options.fallbackImage }, caption, mentions: [targetJid] }
+                : { text: caption, mentions: [targetJid] };
+        return sock.sendMessage(jid || pn, content, options.messageOptions || {});
+    };
     sock.aunuDoctor = () => ({
         experimental: true,
         bundledWaVersion: Array.isArray(baileysVersion.version) ? baileysVersion.version.join('.') : null,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "description": "AunuBaileys \u2014 a WhatsApp Web API for bots that never sleep. Full upstream power with the beloved in-memory store restored and pairing that just works. Forged by AunuCore.",
   "keywords": [
     "whatsapp",