@codexverified/baileys 2.7.9 → 2.8.11

package/README.md

@@ -4,14 +4,14 @@
 
 `@codexverified/baileys` is a Node.js and TypeScript library for building WhatsApp integrations over the Baileys protocol. It provides a familiar socket-based API together with media handling, authentication helpers, newsletter operations, interactive messages, rich content utilities, and account-management features.
 
-The project is developed and maintained by **Codex** with an emphasis on readable source code, explicit behavior, maintainable interfaces, and practical production use.
+The project is developed and maintained by **Codex** with an emphasis on readable source code, explicit behavior, maintainable interfaces,and practical production use.
 
 ## Project Status
 
 | Property | Value |
 | --- | --- |
 | Package | `@codexverified/baileys` |
-| Version | `2.7.5` |
+| Version | `2.8.11` |
 | Runtime | Node.js 20 or newer |
 | Module format | ESM with CommonJS compatibility where supported |
 | Type declarations | Included |
@@ -26,10 +26,10 @@ Install the published package when it is available in the npm registry:
 npm install @codexverified/baileys
 ```
 
-To install the current local build from the provided archive, place `codex-baileys-2.7.5.tgz` in your project directory and run:
+To install the current local build from the provided archive, place `codex-baileys-2.8.11.tgz` in your project directory and run:
 
 ```bash
-npm install ./codex-baileys-2.7.5.tgz
+npm install ./codex-baileys-2.8.11.tgz
 ```
 
 The local archive installs under the package name `@codexverified/baileys`, so application imports remain the same in both cases.
@@ -178,11 +178,104 @@ The package displays the following startup identity when a socket is created:
 
 ```text
 CODEX TECHNOLOGY
-A premium Baileys developed and built by Dev Codex
+A premium Baileys developed and built by codex
 ```
 
 Generated message identifiers use the `CODEX` marker. This branding is informational and does not change the WhatsApp protocol or the message transport format.
 
+## CODEX Rich Menu and Interactive Helpers
+
+The following helpers are available on a socket created with `makeWASocket`. They use the existing message relay and do not change the normal `sendMessage` behavior.
+
+### Spoiler media
+
+Use `spoiler: true` when sending supported media. The WhatsApp client controls the visual spoiler and download presentation.
+
+```javascript
+await sock.sendMessage(jid, {
+  video: { url: './media/clip.mp4' },
+  caption: 'Spoiler media',
+  spoiler: true
+})
+```
+
+### Experimental Gen4 rich menu
+
+`richMenu` creates a Meta AI-style rich-response card with a header, optional image, card sections, stable button IDs, optional toast metadata, disclaimers, carousel or row layout, and a footer URL or image. Buttons may be strings or objects. String buttons receive generated tool IDs; object buttons preserve their supplied `id`. Set `body.carousel: true` for horizontal carousel layout, or leave it false for row layout. On some WhatsApp versions, a button tap may arrive as ordinary message text or through another interactive response envelope, so receiving code should handle both the ID and visible label.
+
+```javascript
+await sock.richMenu(jid, {
+  header: {
+    title: 'Rich Menu',
+    image: { url: 'https://example.com/menu.jpg', mime_type: 'image/jpeg' }
+  },
+  body: {
+    row: true,
+    carousel: false,
+    cards: [{
+      title: 'Menu 1',
+      toast: 'Menu 1 selected',
+      buttons: ['menu2', 'menu3', 'rich3']
+    }, {
+      title: 'Menu 2',
+      buttons: [
+        { id: 'test', text: 'test', toast: 'Test selected' },
+        { id: 'me', label: 'me' },
+        { id: 'rich2', text: 'rich2' }
+      ]
+    }]
+  },
+  footer: {
+    text: 'Telegram channel',
+    url: 'https://t.me/example',
+    image: { url: 'https://example.com/footer.jpg', mime_type: 'image/jpeg' }
+  }
+})
+```
+
+### Status, button grids, tables, and Flows
+
+```javascript
+await sock.sendStatus({ text: 'New status' }, {
+  statusJidList: ['1234567890@s.whatsapp.net']
+})
+
+await sock.sendStatusMentions({ text: 'Mentioned status' }, [
+  '1234567890@s.whatsapp.net',
+  '9876543210@s.whatsapp.net'
+])
+
+await sock.sendRichButtonGrid(jid, {
+  text: 'Choose an option',
+  cards: [{
+    title: 'Actions',
+    buttons: [
+      { id: 'action_one', text: 'Action one' },
+      { id: 'action_two', text: 'Action two' }
+    ]
+  }]
+})
+
+await sock.sendInteractiveTable(jid, {
+  title: 'Plans',
+  headers: ['Name', 'Price'],
+  rows: [['Basic', '$5'], ['Pro', '$10']],
+  buttons: [{ id: 'choose_pro', text: 'Choose Pro' }],
+  footer: 'Select a plan'
+})
+
+await sock.sendWhatsAppFlow(jid, {
+  text: 'Open the form',
+  flowId: 'your-flow-id',
+  flowToken: 'your-flow-token',
+  flowName: 'your-flow-name',
+  flowAction: 'navigate',
+  flowActionPayload: { screen: 'WELCOME' }
+})
+```
+
+These helpers and the rich-menu format are client-dependent experimental features. Use stable IDs and test the receiving message normalization on the WhatsApp versions used by your application.
+
 ## Development
 
 Clone or extract the source archive, then install the package dependencies in the project directory:

package/lib/Socket/index.js

@@ -23,24 +23,21 @@ import { makeGraphQLSocket } from './graphql.js';
 
 // export the last socket layer
 const makeWASocket = (config) => {
-    //  CODEX branding banner 
-    // Printed once per process when a socket is created.
+    // CODEX branding banner. Printed once per process.
     if (!globalThis.__codexBannerShown) {
         globalThis.__codexBannerShown = true;
-        const yellow = '\x1b[93m'; // bright / light yellow
-        const dim = '\x1b[2m';
+        const yellow = '\x1b[93m';
+        const blue = '\x1b[94m';
         const reset = '\x1b[0m';
-        const logo = [
-            '        ',
-            '  ',
-            '                ',
-            '                ',
-            '   ',
-            '        '
-        ].join('\\n');
+        const width = 41;
+        const center = (text) => {
+            const pad = Math.max(0, Math.floor((width - text.length) / 2));
+            return ' '.repeat(pad) + text;
+        };
         console.log(
-            '\\n' + yellow + logo + reset + '\\n' +
-            dim + '  CODEX TECHNOLOGY  a premium Baileys developed and built by Dev Codex' + reset + '\\n'
+            `\n${yellow}${center('CODEX TECHNOLOGY')}${reset}\n` +
+            `${blue}${center('@codexverified/Baileys')}${reset}\n` +
+            `${yellow}${center('premium baileys built by codex')}${reset}\n`
         );
     }
     const userExplicitSyncFlag = typeof config?.syncFullHistory === 'boolean';

package/lib/Socket/{messages-send.js → messages-send (1).js }

@@ -11,7 +11,7 @@ import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/
 import { buildMergedTcTokenIndexWrite, isTcTokenExpired, resolveIssuanceJid, resolveTcTokenJid, shouldSendNewTcToken, storeTcTokensFromIqResult } from '../Utils/tc-token-utils.js';
 import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinaryNode, isHostedLidUser, isHostedPnUser, isJidBot, isJidGroup, isJidMetaAI, isJidNewsletter, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, PSA_WID, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
-import { captureUnifiedResponse, generateCodeBlockContent, generateLatexContent, generateListContent, generateTableContent, generateUnifiedResponseContent } from '../Utils/message-composer.js';
+import { captureUnifiedResponse, generateButtonGridContent, generateCodeBlockContent, generateLatexContent, generateListContent, generateRichMenuContent, generateTableContent, generateUnifiedResponseContent } from '../Utils/message-composer.js';
 import { Baron } from './interactive-handler.js';
 import { collectMetaAIBotParticipantJids, isMetaAIBotResponse, META_AI_BOT_JID } from './aigroups.js';
 import { makeUsernameSocket } from './username.js';
@@ -1203,6 +1203,42 @@ export const makeMessagesSocket = (config) => {
         sendBulkReactions,  //  NEW: Bulk reaction helper
         sendAsMimic,
         sendStatusMention: async (content, jids = []) => baron2.sendStatusWhatsApp(content, jids),
+        sendStatusMentions: async (content, jids = [], options = {}) => {
+            if (!Array.isArray(jids) || jids.length === 0) throw new Boom('sendStatusMentions requires at least one recipient JID', { statusCode: 400 });
+            return sock.sendMessage(STATUS_JID, { ...content, status: true }, { ...options, broadcast: true, statusJidList: normalizeStatusJidList(jids) });
+        },
+        sendStatus: async (content, options = {}) => {
+            const recipients = normalizeStatusJidList(options.statusJidList || content?.statusJidList);
+            return sock.sendMessage(STATUS_JID, { ...content, status: true }, { ...options, broadcast: true, statusJidList: recipients });
+        },
+        richMenu: async (jid, content = {}, options = {}) => {
+            if (!jid) throw new Boom('richMenu requires a target JID', { statusCode: 400 });
+            const message = generateRichMenuContent(content, options.quoted, options);
+            const fullMsg = await generateWAMessageFromContent(jid, message, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+            await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+            return fullMsg;
+        },
+        sendRichButtonGrid: async (jid, grid, options = {}) => {
+            const message = generateButtonGridContent(grid, options.quoted, options);
+            const fullMsg = await generateWAMessageFromContent(jid, message, { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+            await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata });
+            return fullMsg;
+        },
+        sendInteractiveTable: async (jid, table, options = {}) => {
+            const { title = '', headers = [], rows = [], image, buttons = [], footer } = table || {};
+            if (!Array.isArray(headers) || !Array.isArray(rows) || !Array.isArray(buttons)) throw new Boom('sendInteractiveTable expects headers, rows, and buttons arrays', { statusCode: 400 });
+            const lines = [title, headers.length ? `| ${headers.map(String).join(' | ')} |` : '', headers.length ? `| ${headers.map(() => '---').join(' | ')} |` : '', ...rows.map(row => `| ${(Array.isArray(row) ? row : [row]).map(value => String(value ?? '')).join(' | ')} |`)].filter(Boolean);
+            return sock.sendMessage(jid, { ...(image ? { image, caption: lines.join('\\n') } : { text: lines.join('\\n') }), buttons, ...(footer ? { footer } : {}) }, options);
+        },
+        sendWhatsAppFlow: async (jid, flow = {}, options = {}) => {
+            const { text, footer, image, caption, flowId, flowToken, flowName = 'flow', flowAction = 'navigate', flowActionPayload = {} } = flow;
+            if (!flowId || !flowToken) throw new Boom('sendWhatsAppFlow requires flowId and flowToken', { statusCode: 400 });
+            const button = {
+                name: 'flow',
+                buttonParamsJson: JSON.stringify({ flow_id: String(flowId), flow_token: String(flowToken), flow_name: String(flowName), flow_action: String(flowAction), flow_action_payload: flowActionPayload }),
+            };
+            return sock.sendMessage(jid, { ...(image ? { image, caption: caption || text || flowId } : { text: text || flowId }), ...(footer ? { footer } : {}), nativeFlow: [button] }, options);
+        },
         sendTable: async (jid, title, headers, rows, quoted, options = {}) => {
             const { message, messageId } = generateTableContent(title, headers, rows, quoted, options);
             await relayMessage(jid, message, { messageId });

package/lib/Utils/message-composer.js

@@ -465,3 +465,114 @@ export const generateRichMessageContent = (submessages, quoted, options) => {
         messageId: generateMessageIDV2()
     };
 };
+
+
+const richMenuToolId = () => generateMessageIDV2();
+
+const richMenuMedia = (image, inline = false, padding = 4) => {
+    if (!image?.url) return null;
+    const media = {
+        __typename: 'GenAIMediaItem',
+        mime_type: image.mime_type || image.mimeType || 'image/png',
+        url: image.url,
+        url_fallback: image.url,
+        width: image.width || (inline ? 500 : undefined),
+        height: image.height || (inline ? 500 : undefined),
+        expiration_timestamp_ms: Date.now() + 86400000,
+    };
+    if (inline) return {
+        __typename: 'GenAIMarkdownTextUXPrimitive',
+        text: '{{header}}.{{/header}}',
+        inline_entities: [{
+            __typename: 'GenAITextInlineEntity',
+            key: 'header',
+            metadata: {
+                __typename: 'GenAILatexItem', latex_expression: '.', font_height: 24,
+                padding, latex_image: media,
+            },
+        }],
+    };
+    return { __typename: 'GenAIImagePrimitive', preview_image: media, full_image: media };
+};
+
+const richMenuButton = (button, toast = '') => {
+    const isString = typeof button === 'string';
+    const label = isString ? button : (button?.text || button?.label || button?.id || 'Option');
+    return {
+        label: String(label), state: 'PENDING', kind: 'OTHER',
+        tool_call_id: !isString && button?.id != null ? String(button.id) : richMenuToolId(),
+        toast: {
+            label: !isString && button?.toast != null ? String(button.toast) : String(toast || ''),
+            __typename: 'GenAIExtWidgetToast',
+        },
+        __typename: 'GenAI3PExtWidgetCTA',
+    };
+};
+
+export const generateRichMenuContent = (content = {}, quoted, options = {}) => {
+    const header = content.header || {};
+    const body = content.body || {};
+    const footer = content.footer || {};
+    const sections = [];
+    if (header.title) sections.push({ __typename: 'GenAIUnifiedResponseSection', view_model: {
+        __typename: 'GenAISingleLayoutViewModel', primitive: { __typename: 'FOATextPrimitive', text: `# ${String(header.title)}` },
+    } });
+    const headerImage = richMenuMedia(header.image, Boolean(header.image?.inline));
+    if (headerImage) sections.push({ __typename: 'GenAIUnifiedResponseSection', view_model: {
+        __typename: 'GenAISingleLayoutViewModel', primitive: headerImage,
+    } });
+    if (header.disclaimer) sections.push({ __typename: 'GenAIUnifiedResponseSection', view_model: {
+        __typename: 'GenAISingleLayoutViewModel', primitive: {
+            __typename: 'GenAIMarkdownTextUXPrimitive', text: String(header.disclaimerText || ' '),
+        },
+    } });
+    const cards = Array.isArray(body.cards) ? body.cards : [];
+    const buttons = Array.isArray(body.buttons) ? body.buttons : [];
+    if (cards.length) sections.push({ __typename: 'GenAIUnifiedResponseSection', view_model: {
+        __typename: body.carousel || body.row === false ? 'GenAIHScrollLayoutViewModel' : 'GenAIActionRowLayoutViewModel',
+        primitives: cards.map(card => ({
+            __typename: 'GenAI3PExtWidgetPrimitive',
+            header: { __typename: 'GenAI3PExtWidgetStandardHeader', title: String(card?.title || '') },
+            body: {
+                __typename: 'GenAI3PExtCalendarEventList',
+                ctas: (Array.isArray(card?.buttons) ? card.buttons : []).map(button => richMenuButton(button, card?.toast || body.toast)),
+                sections: [],
+            },
+        })),
+    } });
+    else if (buttons.length) sections.push({ __typename: 'GenAIUnifiedResponseSection', view_model: {
+        __typename: 'GenAISingleLayoutViewModel', primitive: {
+            __typename: 'GenAI3PExtWidgetPrimitive',
+            header: { __typename: 'GenAI3PExtWidgetStandardHeader', title: String(body.title || '') },
+            body: { __typename: 'GenAI3PExtCalendarEventList', ctas: buttons.map(button => richMenuButton(button, body.toast)), sections: [] },
+        },
+    } });
+    if (footer.text || footer.url || footer.image?.url) {
+        const footerImage = richMenuMedia(footer.image, true, -5);
+        sections.push({ view_model: {
+            __typename: 'GenAIActionRowLayoutViewModel', primitives: [
+                { __typename: 'GenAIFooterActionPrimitive', cta_text: String(footer.text || 'Open'), cta_type: 'OPEN_URL', cta_url: String(footer.url || '') },
+                ...(footerImage ? [footerImage] : []),
+            ],
+        } });
+    }
+    const unified = { response_id: options.responseId || richMenuToolId(), sections };
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages: [],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: { data: Buffer.from(JSON.stringify(unified)) },
+        contextInfo: { ...buildRichContextInfo(quoted, options), isForwarded: true, forwardingScore: 1, forwardOrigin: 4 },
+    });
+    return buildBotForwardedMessage([], richResponseMessage.contextInfo, richResponseMessage.unifiedResponse);
+};
+
+export const generateButtonGridContent = (grid = {}, quoted, options = {}) => {
+    const { text, footer, cards = [] } = grid;
+    if (!Array.isArray(cards) || cards.length === 0) throw new Error('sendRichButtonGrid expects at least one card');
+    return generateRichMenuContent({
+        header: text ? { title: text } : {},
+        body: { cards: cards.map(card => ({ ...card, buttons: card.buttons || card.nativeFlow || [] })) },
+        footer: footer ? { text: footer } : {},
+    }, quoted, options);
+};
+    

package/lib/index.d.ts

@@ -249,6 +249,21 @@ export interface WASocket {
     managedAccountSyncActivities(): Promise<unknown>;
     managedAccountUpdatePin(pin: string): Promise<unknown>;
 
+    /** Send a status update to an explicit recipient list. */
+    sendStatus(content: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a status update mentioning one or more recipients. */
+    sendStatusMention(content: Record<string, unknown>, jids?: string[], options?: Record<string, unknown>): Promise<unknown>;
+    /** Alias supporting multiple status recipients. */
+    sendStatusMentions(content: Record<string, unknown>, jids?: string[], options?: Record<string, unknown>): Promise<unknown>;
+    /** Send an experimental Gen4 / Meta-AI-style rich menu card. */
+    richMenu(jid: string, content?: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a rich button-card grid. */
+    sendRichButtonGrid(jid: string, grid: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a markdown-style interactive table with buttons. */
+    sendInteractiveTable(jid: string, table: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a WhatsApp native flow button. */
+    sendWhatsAppFlow(jid: string, flow: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+
     // ---- GraphQL layer ----
     setAccessToken(token: string): Promise<void>;
     setWamoAuth(token: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@codexverified/baileys",
-   "version": "2.7.9",
+   "version": "2.8.11",
    "description": "CODEX TECHNOLOGY  a premium Baileys developed and built by Dev Codex, with Meta compositing, bot planning replay, welcome flow, rich messages, interactive messages, albums, and more.",
    "main": "lib/index.js",
    "type": "module",
@@ -26,7 +26,7 @@
       "baileys-fork",
       "baileys-mod",
       "codex technology",
-      "cody ai",
+      "codex ai",
       "bot-planning-replay",
       "codex",
       "interactive-messages",
@@ -43,7 +43,7 @@
       "whatsapp-web"
    ],
    "homepage": "https://github.com/codexverified/baileys-",
-   "author": "Dev Codex",
+   "author": "codexverified",
    "license": "MIT",
    "dependencies": {
       "@adiwajshing/keyed-db": "^0.2.4",