aunubaileys 1.0.52 → 1.0.53

package/README.md

@@ -8,8 +8,8 @@
 [![npm downloads](https://img.shields.io/npm/dt/aunubaileys?style=for-the-badge&logo=npm&logoColor=white)](https://www.npmjs.com/package/aunubaileys)
 [![Fork of WhiskeySockets/Baileys](https://img.shields.io/badge/fork%20of-WhiskeySockets%2FBaileys-25D366?style=for-the-badge&logo=whatsapp&logoColor=white)](https://github.com/WhiskeySockets/Baileys)
 [![License: MIT](https://img.shields.io/badge/license-MIT-yellow?style=for-the-badge)](./LICENSE)
-[![GitHub stars](https://img.shields.io/github/stars/AunuHost/AunuBaileys-lib?style=for-the-badge&logo=github)](https://github.com/AunuHost/AunuBaileys-lib/stargazers)
-[![GitHub forks](https://img.shields.io/github/forks/AunuHost/AunuBaileys-lib?style=for-the-badge&logo=github)](https://github.com/AunuHost/AunuBaileys-lib/forks)
+[![GitHub stars](https://img.shields.io/github/stars/AunuCore/AunuBaileys-lib?style=for-the-badge&logo=github)](https://github.com/AunuCore/AunuBaileys-lib/stargazers)
+[![GitHub forks](https://img.shields.io/github/forks/AunuCore/AunuBaileys-lib?style=for-the-badge&logo=github)](https://github.com/AunuCore/AunuBaileys-lib/forks)
 
 **Full upstream power — with the soul that community forks used to have.**
 The in-memory store is back, legacy exports are back, and every upstream update flows straight in.
@@ -64,6 +64,10 @@ Everything else is pure upstream. When upstream moves, we rebase the patch layer
 
 
 
+### 🧪 What's new in 1.0.53 / Baru di 1.0.53 — EXPERIMENTAL
+
+- 📇 **Five more experimental features (17 total).** **`aunuSideText`** — text with a small picture **at the side**: a name/title beside the picture and the chat under the name (the preview layout group menus use); the picture can be someone's real profile picture (`profileOf`), your own image, the built-in grey **"deleted account"** avatar (`deletedProfile: true`), or no picture at all. **`aunuGhostMention`** — mention every group member invisibly: everyone is notified, the text shows no @ pile-up. **`aunuFakeForward`** — the forwarded look (high forwarding score, optional channel attribution). **`aunuCountdown`** — one message edited down a countdown to a final text. **`aunuSplitText`** — a long text sent as a self-quoting chain. New exported utils: `getDeletedProfileImage()` (the embedded deleted-account avatar PNG) and `buildSideTextAdReply()`.
+
 ### 🧪 What's new in 1.0.52 / Baru di 1.0.52 — EXPERIMENTAL
 
 - 👍 **`aunuCard` gains like/dislike buttons.** The new `likeDislike: true` option appends two quick-reply buttons under the card — **👍 Suka** (id `aunu_like`) and **👎 Tidak Suka** (id `aunu_dislike`) — after any custom buttons. The ids are overridable via `likeId`/`dislikeId`; taps return to the bot as button replies carrying those ids, so votes can be counted. Without the option, card behaviour is exactly as in 1.0.50.

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

@@ -75,6 +75,24 @@ export interface AunuFakeQuoteOptions {
     id?: string;
     quotedMessage?: Record<string, unknown>;
 }
+export interface AunuSideTextOptions {
+    /** The chat text (required). */
+    text: string;
+    /** Name/title beside the picture. `name` is an alias. */
+    title?: string;
+    name?: string;
+    /** Line under the title; defaults to the text itself. */
+    body?: string;
+    /** Side picture as raw bytes... */
+    image?: Buffer | { url: string };
+    /** ...or fetch this JID's real profile picture... */
+    profileOf?: string;
+    /** ...or use the built-in "deleted account" grey avatar... */
+    deletedProfile?: boolean;
+    /** Optional link opened when the preview block is tapped. Never substituted when omitted. */
+    url?: string;
+    messageOptions?: MiscMessageGenerationOptions;
+}
 export interface AunuExperimentalAPI {
     aunuWatermark: (text: string, tag: string) => string;
     aunuReadWatermark: (text: string) => string | null;
@@ -93,5 +111,10 @@ export interface AunuExperimentalAPI {
     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>;
+    aunuSideText: (jid: string, options: AunuSideTextOptions) => Promise<any>;
+    aunuGhostMention: (jid: string, content: Record<string, unknown>, options?: MiscMessageGenerationOptions) => Promise<any>;
+    aunuFakeForward: (jid: string, content: Record<string, unknown>, options?: { score?: number; channelName?: string; channelJid?: string; serverMessageId?: number; messageOptions?: MiscMessageGenerationOptions }) => Promise<any>;
+    aunuCountdown: (jid: string, options?: { from?: number; intervalMs?: number; format?: (n: number) => string; finalText?: string; messageOptions?: MiscMessageGenerationOptions }) => Promise<any>;
+    aunuSplitText: (jid: string, text: string, options?: { maxChars?: number; messageOptions?: MiscMessageGenerationOptions }) => Promise<any[]>;
 }
 export declare const attachAunuExperimental: <T>(sock: T) => T & AunuExperimentalAPI;

package/lib/Socket/aunu-experimental.js

@@ -1,5 +1,5 @@
 import baileysVersion from '../Defaults/baileys-version.json' with { type: 'json' };
-import { appendWatermark, computeTypingDuration, extractWatermark, stripWatermark } from '../Utils/aunu-experimental.js';
+import { appendWatermark, buildSideTextAdReply, computeTypingDuration, encodeWatermark, extractWatermark, getDeletedProfileImage, stripWatermark } from '../Utils/aunu-experimental.js';
 import { isLidUser } from '../WABinary/jid-utils.js';
 import { prepareWAMessageMedia } from '../Utils/messages.js';
 import { randomBytes } from 'crypto';
@@ -42,6 +42,18 @@ const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
  * 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).
+ * 13. Side-profile text — `aunuSideText`: text with a small picture at
+ *     the side, a name beside it and the chat under the name; the
+ *     picture can be a real profile picture, the built-in "deleted
+ *     account" avatar, or absent entirely.
+ * 14. Ghost mention — `aunuGhostMention`: mention every group member
+ *     invisibly (notifications fire, no @ text shows).
+ * 15. Fake forward — `aunuFakeForward`: the forwarded look with a high
+ *     score and optional channel attribution.
+ * 16. Countdown — `aunuCountdown`: one message edited down a countdown
+ *     to a final text.
+ * 17. Split text — `aunuSplitText`: a long text as a self-quoting
+ *     chain of messages.
  */
 export const attachAunuExperimental = (sock) => {
     const scheduled = new Map();
@@ -286,6 +298,132 @@ export const attachAunuExperimental = (sock) => {
         selfDestructPending: destructs.size,
         generatedAt: new Date().toISOString(),
     });
+    /**
+     * EXPERIMENTAL (1.0.53): side-profile text. Sends a text message whose
+     * preview block shows a small picture AT THE SIDE, a name/title next
+     * to it, and the chat text under the name — the layout group menus
+     * use. Picture variants: `image` (Buffer or { url }), `profileOf`
+     * (a JID whose real profile picture is fetched), `deletedProfile:
+     * true` (the built-in grey "deleted account" avatar), or no picture
+     * at all. Client rendering of the preview is version-dependent.
+     */
+    sock.aunuSideText = async (jid, options = {}) => {
+        const { text, title, name, body, url, messageOptions } = options;
+        if (!text)
+            throw new Error('aunuSideText: options.text is required');
+        let thumbnail = null;
+        if (options.deletedProfile)
+            thumbnail = getDeletedProfileImage();
+        else if (Buffer.isBuffer(options.image))
+            thumbnail = options.image;
+        else if (options.profileOf) {
+            try {
+                const ppUrl = await sock.profilePictureUrl(options.profileOf, 'image');
+                if (ppUrl)
+                    thumbnail = Buffer.from(await (await fetch(ppUrl)).arrayBuffer());
+            }
+            catch { /* no picture — the text simply goes without one */ }
+        }
+        else if (options.image?.url)
+            thumbnail = Buffer.from(await (await fetch(options.image.url)).arrayBuffer());
+        const externalAdReply = buildSideTextAdReply({ title: title ?? name ?? '', body: body ?? text, thumbnail, url });
+        return sock.sendMessage(jid, { text, contextInfo: { externalAdReply } }, messageOptions);
+    };
+    /**
+     * EXPERIMENTAL (1.0.53): ghost mention — mention EVERY group member
+     * in the message's mention list without any visible @ text, so all
+     * members are notified while the text stays clean.
+     */
+    sock.aunuGhostMention = async (jid, content, options = {}) => {
+        if (!String(jid).endsWith('@g.us'))
+            throw new Error('aunuGhostMention: jid must be a group JID');
+        const metadata = await sock.groupMetadata(jid);
+        const ids = (metadata?.participants || []).map((p) => p.id).filter(Boolean);
+        const mentions = [...new Set([...(content?.mentions || []), ...ids])];
+        return sock.sendMessage(jid, { ...content, mentions }, options);
+    };
+    /**
+     * EXPERIMENTAL (1.0.53): fake forward — the message carries the
+     * forwarded look: `isForwarded` with a high forwarding score, and
+     * optionally a channel attribution line (name + JID).
+     */
+    sock.aunuFakeForward = async (jid, content, options = {}) => {
+        const contextInfo = {
+            ...(content?.contextInfo || {}),
+            isForwarded: true,
+            forwardingScore: options.score ?? 999,
+        };
+        if (options.channelName) {
+            contextInfo.forwardedNewsletterMessageInfo = {
+                newsletterJid: options.channelJid ?? '120363000000000000@newsletter',
+                newsletterName: options.channelName,
+                contentType: 1,
+                serverMessageId: options.serverMessageId ?? 1,
+            };
+        }
+        return sock.sendMessage(jid, { ...content, contextInfo }, options.messageOptions);
+    };
+    /**
+     * EXPERIMENTAL (1.0.53): countdown — send one message, then edit it
+     * down from `from` to 0 on an interval, finishing with `finalText`.
+     */
+    sock.aunuCountdown = async (jid, options = {}) => {
+        const from = options.from ?? 5;
+        const intervalMs = options.intervalMs ?? 1000;
+        const format = options.format ?? ((n) => `\u23F3 ${n}`);
+        let msg = await sock.sendMessage(jid, { text: format(from) }, options.messageOptions);
+        const key = msg.key;
+        for (let n = from - 1; n >= 0; n--) {
+            await delay(intervalMs);
+            msg = await sock.sendMessage(jid, { text: format(n), edit: key }, options.messageOptions);
+        }
+        if (options.finalText != null) {
+            await delay(intervalMs);
+            msg = await sock.sendMessage(jid, { text: options.finalText, edit: key }, options.messageOptions);
+        }
+        return msg;
+    };
+    /**
+     * EXPERIMENTAL (1.0.53): split text — a long text is sent as a chain
+     * of messages, each quoting the previous one, split on paragraph
+     * boundaries where possible.
+     */
+    sock.aunuSplitText = async (jid, text, options = {}) => {
+        const maxChars = options.maxChars ?? 1000;
+        const chunks = [];
+        let current = '';
+        for (const para of String(text).split(/\n\n+/)) {
+            const pieces = [];
+            let rest = para;
+            while (rest.length > maxChars) {
+                let cut = rest.lastIndexOf(' ', maxChars);
+                if (cut < maxChars * 0.5)
+                    cut = maxChars;
+                pieces.push(rest.slice(0, cut));
+                rest = rest.slice(cut).trimStart();
+            }
+            if (rest)
+                pieces.push(rest);
+            for (const piece of pieces) {
+                if (current && (current.length + 2 + piece.length) > maxChars) {
+                    chunks.push(current);
+                    current = piece;
+                }
+                else
+                    current = current ? current + '\n\n' + piece : piece;
+            }
+        }
+        if (current)
+            chunks.push(current);
+        const sent = [];
+        let prev;
+        for (const chunk of chunks) {
+            const msg = await sock.sendMessage(jid, { text: chunk }, prev ? { ...options.messageOptions, quoted: prev } : options.messageOptions);
+            sent.push(msg);
+            prev = msg;
+        }
+        return sent;
+    };
     return sock;
 };
 //# sourceMappingURL=aunu-experimental.js.map

package/lib/Utils/aunu-experimental.js

@@ -17,6 +17,36 @@ const textDecoder = new TextDecoder();
  * Encode a short string as an invisible zero-width sequence. Returns an
  * empty string for an empty payload.
  */
+/**
+ * EXPERIMENTAL (AunuBaileys-only): a small embedded PNG of the WhatsApp
+ * "deleted account" avatar — a grey silhouette on light grey, drawn
+ * programmatically (96x96, 375 bytes). Used by `aunuSideText` for the
+ * deleted-profile side picture; exported so bots can reuse the look.
+ */
+export const DELETED_PROFILE_PNG_BASE64 = 'iVBORw0KGgoAAAANSUhEUgAAAGAAAABgCAIAAABt+uBvAAABPklEQVR4nO3aTWpCQRCFUVfvTHB1mSSLcZiAoETr56oHvgVUH3ryut7h6/tHNzqsTxAeIECAAAEKDhAgQIAABQcIECBAgIIDBAgQIEB/Op7O6zNkAR1P59t9LtBdmgSmHaB/0ewyLQA9rLNiNA30pM680ShQic6wEaAYoEKdSSNAGUDlOmNGgAABAvTuQE06M0ZuECBAgAAB8i0GKMxobGZASUDepCeMhqe1F4sEeoBpa0i7+Xiga6/1GaKB0gIECBAgQMEBAgQIEKDgAAEC9FlAnjt+IfLfW201koBKaOaZ/GG2CtRKM8PUCDSm02rUBTSs02fUArSi02RUD7So02FUDLSuU25UCbTu0mFUBrQu0mQEaARo3aLPCBCgdaB1hVYjQIAAAXploPXzdxu5QYAAAQL03kDJRs8fDdCdLjutlqODlBNDAAAAAElFTkSuQmCC';
+export const getDeletedProfileImage = () => Buffer.from(DELETED_PROFILE_PNG_BASE64, 'base64');
+/**
+ * EXPERIMENTAL: build the `externalAdReply` object behind `aunuSideText` —
+ * a preview block with the picture at the side, the title where a name
+ * sits, and the body text under the title. URLs are strictly
+ * caller-supplied; nothing is ever substituted.
+ */
+export const buildSideTextAdReply = ({ title, body, thumbnail, url } = {}) => {
+    const ad = {
+        title: title ?? '',
+        body: body ?? '',
+        mediaType: thumbnail ? 1 : 0,
+        renderLargerThumbnail: false,
+        showAdAttribution: false,
+    };
+    if (thumbnail)
+        ad.thumbnail = thumbnail;
+    if (url) {
+        ad.mediaUrl = url;
+        ad.sourceUrl = url;
+    }
+    return ad;
+};
 export const encodeWatermark = (payload) => {
     if (!payload) {
         return '';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.52",
+  "version": "1.0.53",
   "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",