ishumdz-bail 1.0.21 → 1.0.25

package/README.md

@@ -423,6 +423,19 @@ await sock.sendMessage(jid, {
 > card + horizontal row, and a **custom image or GIF** works with one media upload.
 > Set `{ nativeFlow: true }` for vertical native-flow quick_reply buttons instead.
 
+### Button Types — Quick Reference
+
+| Button property           | Tap behavior                                  | Since   |
+| ------------------------- | --------------------------------------------- | ------- |
+| `buttonId` + `buttonText` | Quick reply — sends the id back to your bot   | v1.0.19 |
+| `rows` / `sections`       | Opens a highlighted list sheet on tap         | v1.0.22 |
+| `url`                     | Opens the link / WhatsApp channel immediately | v1.0.23 |
+| `copy`                    | Copies the code to the clipboard              | v1.0.23 |
+| `call`                    | Opens the dialer with the number              | v1.0.23 |
+
+All of them mix freely in one message and render as a single horizontal row
+(when the message has a header) — see the full example below.
+
 ### Text + Horizontal Buttons (location header = zero uploads)
 
 ```javascript
@@ -483,6 +496,87 @@ await sock.sendMessage(jid, {
 })
 ```
 
+### Tap-to-Open List Sheet (rows on a button) — v1.0.22+
+
+Give any horizontal button a `rows` or `sections` array and **tapping it opens a
+highlighted list sheet** — the same sheet classic `listMessage` shows, with section
+titles, a `highlight_label` badge and row descriptions:
+
+```javascript
+await sock.sendMessage(jid, {
+    image: { url: './banner.jpg' },       // or gif / location / video header
+    caption: 'Pong 9 Ms ⚡',
+    footer: 'ISHAN-X MD PRO',
+    buttons: [
+        { buttonText: { displayText: '☰ menu' },  buttonId: 'menu',  type: 1 },
+        { buttonText: { displayText: '🔍 owner' }, buttonId: 'owner', type: 1 },
+        // 📂 this button opens the sheet on tap:
+        {
+            buttonText: { displayText: '📂 allmenus' },
+            buttonId: 'allmenus', type: 1,
+            highlightLabel: '⭐ MAIN',       // optional — badge on the section
+            sectionTitle: 'All Menus',       // optional — section heading
+            rows: [
+                { title: '📥 Download Menu', description: 'Downloader commands', rowId: '.downloadmenu' },
+                { title: '✨ AI Menu',       description: 'AI commands',        rowId: '.aimenu' }
+            ]
+        },
+        // multiple sections? pass `sections` instead of `rows`:
+        {
+            buttonText: { displayText: '⚙️ settings' }, buttonId: 'settings', type: 1,
+            sections: [
+                { title: 'Main', highlight_label: '⭐ MAIN', rows: [ /* ... */ ] },
+                { title: 'More', rows: [ /* ... */ ] }
+            ]
+        }
+    ]
+})
+```
+
+**How it works:**
+
+- `rows` — single-section shortcut (optional `sectionTitle` and `highlightLabel` on the button)
+- `sections` — full control: multiple sections, each with its own `title` and `highlight_label`
+- Each row accepts `{ title, description?, rowId }` (`id` also works)
+- Tapping a row sends back an `interactiveResponseMessage` — parse its `paramsJson`
+  for the row id (the click bridge below handles this)
+- Works in both layouts: the classic horizontal row (with header) and `{ nativeFlow: true }` vertical
+
+### One-Click Action Buttons (URL / Copy / Call) — v1.0.23+
+
+Give a button a `url`, `copy` or `call` value and it becomes a **one-click action
+button** — tapping performs the action directly instead of sending a reply back
+to your bot (opens a link/channel, copies a code, opens the dialer):
+
+```javascript
+await sock.sendMessage(jid, {
+    image: { url: './banner.jpg' },   // location / gif / video header um ok
+    caption: 'Pong 9 Ms ⚡',
+    footer: 'ISHAN-X MD PRO',
+    buttons: [
+        { buttonText: { displayText: '☰ menu' }, buttonId: 'menu', type: 1 },
+        // 📢 one tap → channel/page opens:
+        { buttonText: { displayText: '📢 Channel' }, url: 'https://whatsapp.com/channel/0029V...' },
+        // 🎁 one tap → code copies to clipboard:
+        { buttonText: { displayText: '🎁 Voucher' }, copy: 'ISHAN2026' },
+        // 📞 one tap → dialer opens:
+        { buttonText: { displayText: '📞 Call Owner' }, call: '919999999999' },
+        // a tap-to-open sheet button can share the same message:
+        { buttonText: { displayText: '📂 allmenus' }, buttonId: 'allmenus',
+          highlightLabel: '⭐ MAIN', rows: [ /* ... */ ] }
+    ]
+})
+```
+
+**How it works:**
+
+- `url` → native-flow `cta_url` (WhatsApp channel link, website, wa.me — anything)
+- `copy` → `cta_copy` (coupon codes, voucher codes, pairing codes)
+- `call` → `cta_call` (phone number including country code)
+- Plain buttons + sheet buttons + action buttons all mix in **one horizontal row**
+- Action buttons never send a reply to your bot — nothing to handle in `messages.upsert`
+- Works in groups too — the group auto-converter preserves the native-flow names
+
 ### Text-only (TEXT header, best-effort) & native flow escape hatch
 
 ```javascript
@@ -500,36 +594,106 @@ await sock.sendMessage(jid, {
 })
 ```
 
+### Full Example — Everything in One Message
+
+A complete bot reply: location map-card header, a plain quick-reply, a highlighted
+list-sheet button and a one-click channel button — all in one horizontal row:
+
+```javascript
+await sock.sendMessage(jid, {
+    location: {
+        degreesLatitude: 9.9312,
+        degreesLongitude: 76.2673,
+        name: 'ISHAN-X MD PRO',
+        address: 'Select an option below'
+    },
+    text: 'Pong 9 Ms ⚡\nDeveloper: ISHAN-X × LOVELY',
+    footer: 'ISHAN-X MD PRO',
+    buttons: [
+        // 1) plain quick-reply → sends 'menu' back to your bot
+        { buttonText: { displayText: '☰ menu' }, buttonId: 'menu', type: 1 },
+        // 2) tap-to-open highlighted list sheet
+        {
+            buttonText: { displayText: '📂 allmenus' },
+            buttonId: 'allmenus', type: 1,
+            highlightLabel: '⭐ MAIN',
+            sectionTitle: 'All Menus',
+            rows: [
+                { title: '📥 Download Menu', description: 'Downloader commands', rowId: '.downloadmenu' },
+                { title: '✨ AI Menu',       description: 'AI commands',         rowId: '.aimenu' }
+            ]
+        },
+        // 3) one-click action → opens your channel, nothing is sent back
+        { buttonText: { displayText: '📢 Channel' }, url: 'https://whatsapp.com/channel/0029V...' }
+    ]
+}, { quoted: msg })
+```
+
+> ⚠️ **Limit:** the classic horizontal row renders up to **3 buttons** per message on
+> most clients. Need more? Use `{ nativeFlow: true }` for a vertical layout that
+> supports more buttons, or split across two messages.
+
 ### Handling Button Clicks
 
-Button replies arrive in `messages.upsert` — native flow uses
-`interactiveResponseMessage`, classic uses `buttonsResponseMessage`:
+Button and row taps arrive in `messages.upsert`. Three shapes are possible:
+classic quick replies → `buttonsResponseMessage`, native-flow taps (sheet rows and
+vertical quick replies) → `interactiveResponseMessage`, classic list rows →
+`listResponseMessage`. This one bridge converts all three into a plain command id —
+drop it above your command parser so every existing case keeps working:
 
 ```javascript
+function resolveButtonResponse(msg) {
+    // classic horizontal quick-reply buttons
+    const classic = msg.message?.buttonsResponseMessage?.selectedButtonId
+    if (classic) return classic
+
+    // native flow: sheet rows and vertical quick replies
+    const nf = msg.message?.interactiveResponseMessage?.nativeFlowResponseMessage
+    if (nf?.paramsJson) {
+        try {
+            const p = JSON.parse(native.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
+}
+
 sock.ev.on('messages.upsert', async ({ messages, type }) => {
     if (type !== 'notify') return
     const msg = messages[0]
     if (!msg.message || msg.key.fromMe) return
 
-    let clickedId = msg.message.buttonsResponseMessage?.selectedButtonId
-    const native = msg.message.interactiveResponseMessage?.nativeFlowResponseMessage
-    if (!clickedId && native?.paramsJson) {
-        try { clickedId = JSON.parse(native.paramsJson).id } catch {}
-    }
+    // turn any button / row tap into normal command text:
+    const clicked = resolveButtonResponse(msg)
+    if (clicked) msg.message = { conversation: clicked }
 
-    if (clickedId === 'menu')  await sock.sendMessage(msg.key.remoteJid, { text: '📋 MENU...' })
-    if (clickedId === 'owner') await sock.sendMessage(msg.key.remoteJid, { text: '👑 Owner...' })
+    // your existing command parser keeps working untouched:
+    // switch (command) { case 'menu': ... case 'owner': ... }
 })
 ```
 
+Action buttons (`url` / `copy` / `call`) never send a reply — nothing to handle here.
+
 > **Notes**
-> - Groups: `listMessage` / `buttonsMessage` / `templateMessage` are auto-converted to
->   interactive native flow on send — buttons work in groups too.
-> - WhatsApp Web and very old clients don't render native flow cards — mobile clients
->   (recent Android/iOS) render them fully.
-> - Full working demo: [`examples/ping-buttons.js`](examples/ping-buttons.js)
->   (`.ping` → image + horizontal buttons + click handling) and a visual preview in
->   [`banner-preview.html`](banner-preview.html).
+> - **Groups:** `listMessage` / `buttonsMessage` / `templateMessage` are auto-converted
+>   to interactive native flow on send — and buttons that carry a native-flow action
+>   (list sheet, URL, copy, call) are preserved as-is, so sheets and one-click
+>   actions work in groups too (v1.0.23+).
+> - **Client support:** modern Android / iOS / Business clients render everything on
+>   this page. WhatsApp Web and very old clients may show only the vertical
+>   native-flow layout.
+> - **Media headers:** one media header per message (image, GIF or video). The
+>   location map card needs **no media upload at all**.
+> - Full working demos: [`examples/ping-buttons.js`](examples/ping-buttons.js)
+>   (`.ping` → image + horizontal buttons + click handling) and
+>   [`examples/menu-buttons.js`](examples/menu-buttons.js)
+>   (`.menu` → custom image/GIF + buttons + highlighted menu sheet), plus a visual
+>   preview in [`banner-preview.html`](banner-preview.html).
 
 ---
 
@@ -1157,7 +1321,8 @@ Made with ❤️ by **Lovely**
 
 ## 🚀 Hosting / Troubleshooting (OptikLink, Pterodactyl, etc.)
 
-Bot hosting panels la `npm install` fail aana, idhu dhaan common reasons:
+If `npm install` fails on bot hosting panels (OptikLink, Pterodactyl, etc.), these are
+the most common reasons:
 
 ### ❌ `npm error code EALLOWGIT`
 

package/lib/Socket/messages-send.js

@@ -602,16 +602,24 @@ export const makeMessagesSocket = (config) => {
 				    		header: list.title? { title: list.title, hasMediaAttachment: false, subtitle: '' } : undefined,
 				    		contextInfo: list.contextInfo
 				    	}
-			    	}
-		    	} else if (message.buttonsMessage) {
-			    	const bMsg = message.buttonsMessage
-			    	const buttons = (bMsg.buttons || []).map(btn => ({
-				    	name: 'quick_reply',
-			    		buttonParamsJson: JSON.stringify({
-				    		display_text: btn.buttonText?.displayText || btn.buttonText || '',
-			    			id: btn.buttonId || btn.buttonText?.displayText || ''
-			    		})
-			    	}))
+			    	}		    	} else if (message.buttonsMessage) {
+		    		const bMsg = message.buttonsMessage
+		    		// PATCH: buttons that carry nativeFlowInfo (single_select sheet /
+		    		// cta_url / cta_copy / cta_call) keep their native flow name so
+		    		// sheets and one-click actions still work in groups — only plain
+		    		// buttons degrade to quick_reply.
+		    		const buttons = (bMsg.buttons || []).map(btn => {
+			    		if (btn.nativeFlowInfo?.name) {
+			    			return { name: btn.nativeFlowInfo.name, buttonParamsJson: btn.nativeFlowInfo.paramsJson || '{}' }
+			    		}
+			    		return {
+			    			name: 'quick_reply',
+			    			buttonParamsJson: JSON.stringify({
+			    				display_text: btn.buttonText?.displayText || btn.buttonText || '',
+			    				id: btn.buttonId || btn.buttonText?.displayText || ''
+			    			})
+			    		}
+			    	})
 		    		message = {
 			    		interactiveMessage: {
 				    		nativeFlowMessage: { buttons, messageParamsJson: '', messageVersion: 1 },

package/lib/Utils/messages.js

@@ -524,6 +524,62 @@ const BUTTONS_INVISIBLE_PNG = () => Buffer.from(
 	'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=',
 	'base64'
 )
+// PATCH: rows/sections on a button → tapping it opens a native-flow list
+// sheet (the same sheet classic listMessage shows). A button may carry
+// inline `rows` (auto-wrapped in one section, optional button-level
+// `highlightLabel` / `sectionTitle`) or a full `sections` array where each
+// section is { title?, highlight_label?, rows: [{ title, description?, rowId|id }] }.
+const buildButtonSections = (b) => {
+	let sections = null
+	if (Array.isArray(b?.sections) && b.sections.length) {
+		sections = b.sections
+	} else if (Array.isArray(b?.rows) && b.rows.length) {
+		sections = [{
+			title: b.sectionTitle || b.buttonText?.displayText || b.displayText || 'Menu',
+			...(b.highlightLabel ? { highlight_label: b.highlightLabel } : {}),
+			rows: b.rows
+		}]
+	}
+	if (!sections) return null
+	return sections.map(s => ({
+		...(s.title ? { title: s.title } : {}),
+		...(s.highlight_label || s.highlightLabel ? { highlight_label: s.highlight_label || s.highlightLabel } : {}),
+		rows: (s.rows || []).map(r => ({
+			title: r.title,
+			...(r.description ? { description: r.description } : {}),
+			id: r.rowId ?? r.id ?? r.title
+		}))
+	}))
+}
+// PATCH: one-click action buttons — `url` opens a link/channel, `copy`
+// copies a code, `call` dials a number. Sent as native-flow CTA buttons
+// (classic: type NATIVE_FLOW + nativeFlowInfo; nativeFlow: cta_* names).
+const buildActionFlow = (b) => {
+	if (b?.url) return { name: 'cta_url', params: { display_text: b.buttonText?.displayText || b.displayText || 'Open', url: b.url, merchant_url: b.url } }
+	if (b?.copy) return { name: 'cta_copy', params: { display_text: b.buttonText?.displayText || b.displayText || 'Copy', id: b.buttonId || b.buttonText?.displayText || 'copy', copy_code: b.copy } }
+	if (b?.call) return { name: 'cta_call', params: { display_text: b.buttonText?.displayText || b.displayText || 'Call', phone_number: String(b.call) } }
+	return null
+}
+const normalizeClassicButton = (b) => {
+	const out = { ...b, type: proto.Message.ButtonsMessage.Button.Type.RESPONSE }
+	const action = buildActionFlow(b)
+	if (action) {
+		out.type = proto.Message.ButtonsMessage.Button.Type.NATIVE_FLOW
+		out.nativeFlowInfo = { name: action.name, paramsJson: JSON.stringify(action.params) }
+		return out
+	}
+	const sections = buildButtonSections(b)
+	if (sections) {
+		out.nativeFlowInfo = {
+			name: 'single_select',
+			paramsJson: JSON.stringify({
+				title: b.buttonText?.displayText || b.displayText || 'Menu',
+				sections
+			})
+		}
+	}
+	return out
+}
 export const generateWAMessageContent = async (message, options) => {
     var _a, _b;
     let m = {};
@@ -596,12 +652,27 @@ export const generateWAMessageContent = async (message, options) => {
         m = { interactiveMessage };
     }
 	else if ('buttonsMessage' in message && !!message.buttonsMessage) {
-		// PATCH: raw buttonsMessage — always classic pass-through. Modern clients
-		// render the horizontal row when a header exists (image/video/document/
-		// location) or when a thumbnail header is attached; text-only without any
-		// header is the "version doesn't support it" case. Add a header in that
-		// situation, or use the `buttons` API which auto-adds one.
-		m = { buttonsMessage: proto.Message.ButtonsMessage.create(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.
+		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))
+		if (!hasHeader) {
+			try {
+				const media = await prepareWAMessageMedia({ image: BUTTONS_INVISIBLE_PNG() }, options)
+				raw.imageMessage = media.imageMessage
+				raw.headerType = ButtonType.IMAGE
+			} catch { /* upload failed — send as-is */ }
+		}
+		m = { buttonsMessage: raw };
 	}
 	else if ('buttons' in message && !!message.buttons) {
         // PATCH: `buttons` API — HORIZONTAL button row via classic ButtonsMessage
@@ -610,13 +681,29 @@ export const generateWAMessageContent = async (message, options) => {
         // thumbnail for text-only). Set { nativeFlow: true } to opt out and get
         // vertical native-flow quick_reply buttons instead.
         if (message.nativeFlow === true) {
-            const flowButtons = message.buttons.map(b => ({
-                name: 'quick_reply',
-                buttonParamsJson: JSON.stringify({
-                    display_text: b.buttonText?.displayText || b.displayText || b.text || '',
-                    id: b.buttonId || b.id || b.buttonText?.displayText || ''
-                })
-            }));
+            const flowButtons = message.buttons.map(b => {
+                const action = buildActionFlow(b);
+                if (action) {
+                    return { name: action.name, buttonParamsJson: JSON.stringify(action.params) };
+                }
+                const sections = buildButtonSections(b);
+                if (sections) {
+                    return {
+                        name: 'single_select',
+                        buttonParamsJson: JSON.stringify({
+                            title: b.buttonText?.displayText || b.displayText || 'Menu',
+                            sections
+                        })
+                    };
+                }
+                return {
+                    name: 'quick_reply',
+                    buttonParamsJson: JSON.stringify({
+                        display_text: b.buttonText?.displayText || b.displayText || b.text || '',
+                        id: b.buttonId || b.id || b.buttonText?.displayText || ''
+                    })
+                };
+            });
             const interactiveMessage = {
                 nativeFlowMessage: {
                     buttons: flowButtons,
@@ -638,7 +725,7 @@ export const generateWAMessageContent = async (message, options) => {
         else if ('location' in message && !!message.location) {
             const loc = message.location;
             const buttonsMessage = {
-                buttons: message.buttons.map(b => ({ ...b, type: proto.Message.ButtonsMessage.Button.Type.RESPONSE })),
+                buttons: message.buttons.map(b => normalizeClassicButton(b)),
                 contentText: message.text || message.caption || '',
                 headerType: ButtonType.LOCATION,
                 locationMessage: {
@@ -662,7 +749,7 @@ export const generateWAMessageContent = async (message, options) => {
         }
         else {
             const buttonsMessage = {
-                buttons: message.buttons.map(b => ({ ...b, type: proto.Message.ButtonsMessage.Button.Type.RESPONSE }))
+                buttons: message.buttons.map(b => normalizeClassicButton(b))
             };
             if ('footer' in message && !!message.footer) {
                 buttonsMessage.footerText = message.footer;

package/package.json

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