ishumdz-bail 1.0.26 → 1.0.29

package/README.md

@@ -651,7 +651,7 @@ function resolveButtonResponse(msg) {
     const nf = msg.message?.interactiveResponseMessage?.nativeFlowResponseMessage
     if (nf?.paramsJson) {
         try {
-            const p = JSON.parse(native.paramsJson)
+            const p = JSON.parse(nf.paramsJson)
             return p.id || p.selectedId || p.selected_row_id || null
         } catch { /* ignore */ }
     }
@@ -695,6 +695,114 @@ Action buttons (`url` / `copy` / `call`) never send a reply — nothing to handl
 >   (`.menu` → custom image/GIF + buttons + highlighted menu sheet), plus a visual
 >   preview in [`banner-preview.html`](banner-preview.html).
 
+### Base Compatibility — cantarella / Case X Style Code (v1.0.27+)
+
+Code copied from other Baileys bases (cantarella-baileys, Case X Plugin YOUHU MD, etc.)
+runs without changes — and renders as a **horizontal one-line row** just like those
+bases. Three shapes are accepted:
+
+**1) Raw `buttonsMessage` classic menu card — mixed extras are flattened.** A raw
+classic message that mixes `nativeFlowInfo` (single_select sheet) or `cta_*` buttons
+with plain buttons **stays classic horizontal**: the header (location/image/video)
+is preserved, every extra becomes a plain button with its original `buttonId`, and
+its click arrives as a normal `buttonsResponseMessage` — so your bot can send the
+list sheet / URL action itself (e.g. a separate `nativeFlow: true` message):
+
+```javascript
+// Case X / cantarella style — works as-is:
+await sock.sendMessage(jid, {
+    buttonsMessage: {
+        locationMessage: { degreesLatitude: 0, degreesLongitude: 0, name: 'Youhu base', address: '📍Today' },
+        contentText: menuText, footerText: footer, headerType: 6,
+        buttons: [
+            { buttonId: 'menu', buttonText: { displayText: '☰ menu' }, type: 1,
+              nativeFlowInfo: { name: 'single_select', paramsJson: JSON.stringify({
+                  title: 'Pilih Menu',
+                  sections: [{ title: 'base', highlight_label: '🔥', rows: [{ title: 'ping', description: 'live', id: '/ping' }] }]
+              }) } },
+            { buttonId: 'sc', buttonText: { displayText: '⌕ script' }, type: 1 }
+        ]
+    }
+})
+```
+
+**2) Raw `interactiveMessage` native-flow card — straight through `sendMessage`.**
+No `generateWAMessageFromContent` + `relayMessage` dance needed (though that still
+works too). `messageVersion` defaults to 1:
+
+```javascript
+await sock.sendMessage(jid, {
+    interactiveMessage: {
+        body: { text: 'Pairing code: 1234-5678' },
+        footer: { text: 'Tap to copy' },
+        header: { hasMediaAttachment: false },
+        nativeFlowMessage: {
+            buttons: [{ name: 'cta_copy', buttonParamsJson: JSON.stringify({ display_text: 'Copy', copy_code: '12345678' }) }]
+        }
+    }
+})
+
+// short form also accepted:
+await sock.sendMessage(jid, { interactiveMessage: { buttons: [{ name: 'quick_reply', buttonParamsJson: '{"display_text":"hi","id":"hi"}' }] } })
+```
+
+**3) Plain raw `buttonsMessage`** (no native-flow extras) stays classic and gets the
+automatic invisible-PNG header when you omit one. Flow params are accepted as
+`paramsJson` or `buttonParamsJson`.
+
+> 💡 **Want the tap-to-open sheet too?** Send it as a second message when the button
+> is clicked (see `examples/menu-buttons.js` — the `allmenus` case). Mixing a sheet
+> into the same classic row is what produced the "doesn't support it" bubble; the
+> library keeps the row safe by flattening extras, and the two-message pattern gives
+> you both layouts.
+
+### One-Tap Horizontal Button → Automatic List Sheet — v1.0.28+
+
+`attachSheetAutoReply` does the two-message pattern **for you**: register it once,
+and when the user taps a horizontal button, the list sheet is sent automatically —
+no extra code in your `messages.upsert` handler:
+
+```javascript
+const { makeWASocket, attachSheetAutoReply } = require('ishumdz-bail')
+
+const sock = makeWASocket({ auth: state, ... })
+
+// register ONCE, right after creating the socket:
+attachSheetAutoReply(sock, {
+    // click id → full sheet (auto-sent, click never reaches your parser)
+    allmenus: {
+        text: '📂 *ALL MENUS* — tap a section 👇',
+        footer: 'ISHAN-X MD PRO',
+        buttonText: '📂 open menu',
+        sectionTitle: 'All Menus',
+        highlightLabel: '⭐ MAIN',
+        rows: [
+            { title: '📥 Download Menu', description: 'Downloader commands', rowId: '.downloadmenu' },
+            { title: '✨ AI Menu',       description: 'AI commands',         rowId: '.aimenu' },
+            { title: '🎮 Game Menu',     description: 'Fun & games',         rowId: '.gamemenu' }
+        ]
+    },
+    // shorthand: click id → rewrite into a normal command for your parser
+    support: '.owner'
+})
+
+// then your horizontal row stays 100% plain → guaranteed one-line render:
+await sock.sendMessage(jid, {
+    location: { degreesLatitude: 0, degreesLongitude: 0,
+                name: 'ISHAN-X MD PRO', address: '📂 Select Menu 👇' },
+    text: menuText, footer,
+    buttons: [
+        { buttonText: { displayText: '📂 allmenus' }, buttonId: 'allmenus', type: 1 },
+        { buttonText: { displayText: '👤 owner' },    buttonId: 'owner',    type: 1 },
+        { buttonText: { displayText: '⚡ ping' },      buttonId: 'ping',     type: 1 }
+    ]
+}, { quoted: msg })
+// user taps "allmenus" → sheet opens instantly; taps "owner" → your parser gets '.owner'
+```
+
+Also exported: `sendSheet(sock, jid, entry, quoted)` (send a sheet manually) and
+`decodeButtonClick(msg)` (the click bridge, shipped with the library).
+
 ---
 
 ## 🚫 Ban Checker

package/lib/Pro/sheet-buttons.js

@@ -0,0 +1,179 @@
+/**
+ * sheet-buttons.js — one-tap horizontal button → automatic list sheet (v1.0.28+)
+ *
+ * Classic horizontal rows cannot carry a native-flow sheet inside the SAME
+ * message on current clients (that mix renders as "version doesn't support
+ * it"). The working pattern is TWO messages: the horizontal row, and — when
+ * the user clicks the menu button — a native-flow list sheet sent
+ * automatically. This module does the second half for you:
+ *
+ *   const { attachSheetAutoReply } = require('ishumdz-bail')
+ *
+ *   attachSheetAutoReply(sock, {
+ *       // click id → full sheet definition
+ *       allmenus: {
+ *           text: '📂 *ALL MENUS* — tap a section 👇',
+ *           footer: 'ISHAN-X MD PRO',
+ *           buttonText: '📂 open menu',
+ *           highlightLabel: '⭐ MAIN',
+ *           sectionTitle: 'All Menus',
+ *           rows: [
+ *               { title: '📥 Download Menu', description: 'Downloaders', rowId: '.downloadmenu' },
+ *               { title: '✨ AI Menu',       description: 'AI commands', rowId: '.aimenu' }
+ *           ]
+ *       },
+ *       // or a shorthand: rewrite the click into another command
+ *       support: '.owner'
+ *   })
+ *
+ * Now a horizontal row can stay 100% plain (guaranteed one-line render):
+ *
+ *   await sock.sendMessage(jid, {
+ *       location: { degreesLatitude: 0, degreesLongitude: 0,
+ *                   name: 'ISHAN-X MD PRO', address: '📂 Select Menu 👇' },
+ *       text: menuText, footer,
+ *       buttons: [
+ *           { buttonText: { displayText: '📂 allmenus' }, buttonId: 'allmenus', type: 1 },
+ *           { buttonText: { displayText: '👤 owner' },    buttonId: 'owner',    type: 1 }
+ *       ]
+ *   })
+ *
+ * User taps "allmenus" → the sheet opens instantly, and your own
+ * messages.upsert handler is NOT called for that click (consumed).
+ * A shorthand entry rewrites the click into the given command text and
+ * lets your normal command parser handle it.
+ */
+
+// Decode any button / sheet-row / list-row click into its id (same bridge
+// the examples use, now shipped with the library).
+export function decodeButtonClick(msg) {
+    // classic horizontal quick-reply buttons
+    const classic = msg?.message?.buttonsResponseMessage?.selectedButtonId
+    if (classic) return classic
+
+    // native flow (sheet rows / card quick replies)
+    const nf = msg?.message?.interactiveResponseMessage?.nativeFlowResponseMessage
+    if (nf?.paramsJson) {
+        try {
+            const p = JSON.parse(nf.paramsJson)
+            return p.id || p.selectedId || p.selected_row_id || null
+        } catch { /* ignore */ }
+    }
+
+    // classic listMessage rows
+    const list = msg?.message?.listResponseMessage?.singleSelectReply?.selectedRowId
+    if (list) return list
+
+    return null
+}
+
+const normalizeRows = (rows) => (rows || []).map(r => ({
+    title: r.title,
+    ...(r.description ? { description: r.description } : {}),
+    id: r.rowId ?? r.id ?? r.title
+}))
+
+const buildSections = (entry) => {
+    if (Array.isArray(entry.sections) && entry.sections.length) {
+        return entry.sections.map(s => ({
+            ...(s.title ? { title: s.title } : {}),
+            ...(s.highlight_label || s.highlightLabel ? { highlight_label: s.highlight_label || s.highlightLabel } : {}),
+            rows: normalizeRows(s.rows)
+        }))
+    }
+    return [{
+        title: entry.sectionTitle || entry.buttonText || 'Menu',
+        ...(entry.highlightLabel ? { highlight_label: entry.highlightLabel } : {}),
+        rows: normalizeRows(entry.rows)
+    }]
+}
+
+const normalizeHandlers = (handlers) => {
+    const sheets = {}
+    const commands = {}
+    for (const [id, val] of Object.entries(handlers || {})) {
+        if (typeof val === 'string') {
+            commands[id] = val
+        } else if (val && (Array.isArray(val.rows) || Array.isArray(val.sections))) {
+            sheets[id] = val
+        }
+    }
+    return { sheets, commands }
+}
+
+/**
+ * Manually send a native-flow list sheet (the tap-to-open menu).
+ * attachSheetAutoReply calls this for you on a matching click.
+ */
+export async function sendSheet(sock, jid, entry, quoted) {
+    const sections = buildSections(entry)
+    return sock.sendMessage(jid, {
+        text: entry.text || '📋 Select an option 👇',
+        ...(entry.footer ? { footer: entry.footer } : {}),
+        nativeFlow: true,
+        buttons: [{
+            buttonText: { displayText: entry.buttonText || '☰ menu' },
+            buttonId: entry.buttonId || 'sheet',
+            type: 1,
+            sections
+        }]
+    }, quoted ? { quoted } : {})
+}
+
+/**
+ * Register automatic sheet replies on a socket.
+ *
+ * @param {object} sock     the makeWASocket() instance
+ * @param {object} handlers map of clickId → sheet definition { text?, footer?,
+ *                          buttonText?, sectionTitle?, highlightLabel?, rows|sections }
+ *                          OR clickId → '.command' string shorthand
+ * @returns {Function} uninstall — restores the original sock.ev.on
+ */
+export function attachSheetAutoReply(sock, handlers) {
+    const { sheets, commands } = normalizeHandlers(handlers)
+
+    async function handleUpsert(payload) {
+        const { messages, type } = payload || {}
+        if (type !== 'notify' || !Array.isArray(messages)) return false
+        for (const msg of messages) {
+            if (!msg?.message || msg.key?.fromMe) continue
+            const clicked = decodeButtonClick(msg)
+            if (!clicked) continue
+
+            // 1) full sheet definition → send the sheet, consume the click
+            const entry = sheets[clicked]
+            if (entry) {
+                try {
+                    await sendSheet(sock, msg.key.remoteJid, { ...entry, buttonId: clicked }, msg)
+                } catch (e) {
+                    try { sock.logger?.error?.({ err: e }, 'sheet auto-reply failed') } catch { /* ignore */ }
+                }
+                return true
+            }
+
+            // 2) command shorthand → rewrite into normal command text for the parser
+            const cmd = commands[clicked]
+            if (cmd) {
+                msg.message = { conversation: cmd }
+                return false
+            }
+        }
+        return false
+    }
+
+    // Wrap the user's messages.upsert registration so the sheet fires first
+    // and consumed clicks never reach the bot's command parser.
+    const origOn = sock.ev.on.bind(sock.ev)
+    sock.ev.on = function (ev, handler) {
+        if (ev === 'messages.upsert') {
+            return origOn(ev, async (...args) => {
+                const consumed = await handleUpsert(args[0]).catch(() => false)
+                if (consumed) return true
+                return handler(...args)
+            })
+        }
+        return origOn(ev, handler)
+    }
+
+    return () => { sock.ev.on = origOn }
+}

package/lib/Utils/messages.js

@@ -654,20 +654,68 @@ export const generateWAMessageContent = async (message, options) => {
         applyContextInfoAndMentions(interactiveMessage, message);
         m = { interactiveMessage };
     }
+	else if ('interactiveMessage' in message && !!message.interactiveMessage) {
+		// PATCH (1.0.27): cantarella / Case X-style RAW interactiveMessage
+		// pass-through — send the card exactly like those bases do, but via a
+		// normal sendMessage call. Two accepted shapes:
+		//   { interactiveMessage: { body, footer, header, nativeFlowMessage: { buttons } } }
+		//   { interactiveMessage: { buttons } }                       (short form)
+		// messageVersion defaults to 1 (0 renders greyed-out placeholders).
+		let card = message.interactiveMessage;
+		if (card && !card.nativeFlowMessage && Array.isArray(card.buttons)) {
+			const { buttons, messageParamsJson, ...rest } = card;
+			card = { ...rest, nativeFlowMessage: { buttons, messageParamsJson: messageParamsJson || "" } };
+		}
+		if (card?.nativeFlowMessage && (card.nativeFlowMessage.messageVersion == null || card.nativeFlowMessage.messageVersion === 0)) {
+			card.nativeFlowMessage.messageVersion = 1;
+		}
+		if (card && !card.body && 'text' in message && !!message.text) {
+			card.body = { text: message.text };
+		}
+		m = { interactiveMessage: card };
+	}
 	else if ('buttonsMessage' in message && !!message.buttonsMessage) {
 		// PATCH: raw buttonsMessage — classic pass-through. Modern clients render
 		// the horizontal row only when a header exists (image/video/document/
 		// location). A text-only raw message WITHOUT any header is exactly the
 		// "version doesn't support it" case — so when the caller passed none, we
 		// attach the invisible 1x1 PNG image header automatically (same trick the
-		// `buttons` API uses) and the row always renders. This is unconditional:
-		// header-less raw messages can never produce the "not supported" bubble.
+		// `buttons` API uses) and the row always renders.
 		const raw = proto.Message.ButtonsMessage.fromObject(message.buttonsMessage)
 		// NOTE: fromObject turns missing fields into null (protobuf defaults), so
 		// a nullish headerType (= caller never set it) counts as "no header" too.
 		const hasHeader = !!(raw.imageMessage || raw.videoMessage || raw.documentMessage ||
 			raw.locationMessage ||
 			(raw.headerType != null && raw.headerType !== ButtonType.EMPTY && raw.headerType !== ButtonType.UNKNOWN))
+		// PATCH (1.0.27): a raw classic message that MIXES native-flow extras
+		// (single_select nativeFlowInfo, cta_* buttons) into a ButtonsMessage is
+		// the Case X / cantarella menu-card pattern — on current clients it
+		// renders as "version doesn't support it" (real-device evidence). Convert
+		// the whole message to a native-flow interactive card that renders fully.
+		// Read the caller's ORIGINAL button objects — proto fromObject drops
+		// unknown fields (e.g. nativeFlowInfo.buttonParamsJson), and some bases
+		// (cantarella) put params there.
+		const inputButtons = Array.isArray(message.buttonsMessage.buttons) ? message.buttonsMessage.buttons : raw.buttons
+		const rawExtras = (inputButtons || []).filter(b =>
+			b?.nativeFlowInfo?.name || Number(b?.type) === proto.Message.ButtonsMessage.Button.Type.NATIVE_FLOW)
+		if (rawExtras.length) {
+			// PATCH (1.0.28): a raw classic message that MIXES native-flow extras
+			// (single_select nativeFlowInfo, cta_* buttons) into a ButtonsMessage is
+			// the Case X / cantarella menu-card pattern — on current clients it
+			// renders as "version doesn't support it" (real-device evidence).
+			// Instead of upgrading to the vertical native-flow card, keep the
+			// HORIZONTAL classic layout: every extra becomes a plain RESPONSE
+			// button with its original buttonId, clicks arrive as
+			// buttonsResponseMessage, and the bot sends the list sheet / URL /
+			// copy action itself (e.g. a separate nativeFlow message). The header
+			// (location/image/video/document) is preserved untouched — that is the
+			// proven horizontal Case X / cantarella render.
+			raw.buttons = inputButtons.map(b => proto.Message.ButtonsMessage.Button.fromObject({
+				buttonId: b?.buttonId || b?.buttonText?.displayText || 'button',
+				buttonText: { displayText: b?.buttonText?.displayText || b?.displayText || 'Button' },
+				type: proto.Message.ButtonsMessage.Button.Type.RESPONSE
+			}))
+		}
 		if (!hasHeader) {
 			try {
 				const media = await prepareWAMessageMedia({ image: BUTTONS_INVISIBLE_PNG() }, options)

package/lib/index.js

@@ -2,6 +2,7 @@ import makeWASocket from './Socket/index.js';
 import chalk from "chalk";
 import { enableCallAutoAnswer, getActiveVoipClient, CallState } from './Caller/auto-answer.js';
 import { attachProMethods } from './Pro/index.js';
+import { attachSheetAutoReply, sendSheet, decodeButtonClick } from './Pro/sheet-buttons.js';
 import * as PollsPro from './Pro/polls.js';
 import * as NewsletterPro from './Pro/newsletter.js';
 import * as StatusPro from './Pro/status.js';
@@ -91,5 +92,8 @@ export const removeProfilePicture = ProfilePro.removeProfilePicture;
 export const rejectCall = ProfilePro.rejectCall;
 
 export { enableCallAutoAnswer, getActiveVoipClient, CallState, attachProMethods, makeWASocket };
+
+// One-tap horizontal button → automatic list sheet (v1.0.28+)
+export { attachSheetAutoReply, sendSheet, decodeButtonClick };
 export default makeWASocket;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ishumdz-bail",
-    "version": "1.0.26",
+    "version": "1.0.29",
     "description": "WhatsApp API Modification By Lovely",
     "keywords": [
         "whatsapp",