@crysnovax/baileys 2.6.1 → 2.6.3

package/lib/Utils/messages-media.js

@@ -220,6 +220,80 @@ export const generateProfilePicture = async (mediaUpload, dimensions) => {
         img: await img
     };
 };
+// crysnovax@HD-Profile --- Like generateProfilePicture but skips resize/crop.
+// Re-encodes to JPEG so WA always gets valid image bytes.
+// crysnovax@HD-Profile --- HD mode: preserves original aspect ratio, no crop.
+// WhatsApp server accepts max 720px on any side. Images under 720px pass through
+// unchanged. Larger images are scaled down proportionally to fit within 720px.
+export const generateProfilePictureHD = async (mediaUpload) => {
+    let buffer;
+    if (Buffer.isBuffer(mediaUpload)) {
+        buffer = mediaUpload;
+    }
+    else {
+        const { stream } = await getStream(mediaUpload);
+        buffer = await toBuffer(stream);
+    }
+
+    const lib = await getImageProcessingLibrary();
+    let img;
+
+    if ('sharp' in lib && lib.sharp?.default) {
+        const metadata = await lib.sharp.default(buffer).metadata();
+        const origWidth = metadata.width || 720;
+        const origHeight = metadata.height || 720;
+        const maxDim = Math.max(origWidth, origHeight);
+
+        // WhatsApp server limit: 720px max dimension
+        // If already under 720, send as-is. If larger, scale down proportionally.
+        const needsResize = maxDim > 720;
+
+        let pipeline = lib.sharp.default(buffer);
+
+        if (needsResize) {
+            pipeline = pipeline.resize(720, 720, {
+                fit: 'inside',
+                withoutEnlargement: true
+            });
+        }
+
+        img = pipeline
+            .jpeg({ quality: 85, mozjpeg: true })
+            .toBuffer();
+    }
+    else if ('image' in lib && lib.image?.Transformer) {
+        // @napi-rs/image — cap at 720 via resize
+        img = new lib.image
+            .Transformer(buffer)
+            .resize(720, 720)
+            .jpeg(85);
+    }
+    else if ('jimp' in lib && lib.jimp?.Jimp) {
+        const jimp = await lib.jimp.Jimp.read(buffer);
+        const origWidth = jimp.width;
+        const origHeight = jimp.height;
+        const maxDim = Math.max(origWidth, origHeight);
+
+        let processed = jimp;
+        if (maxDim > 720) {
+            const scale = 720 / maxDim;
+            processed = jimp.resize({
+                w: Math.round(origWidth * scale),
+                h: Math.round(origHeight * scale),
+                mode: lib.jimp.ResizeStrategy.BILINEAR
+            });
+        }
+
+        img = processed.getBuffer('image/jpeg', { quality: 85 });
+    }
+    else {
+        throw new Boom('No image processing library available');
+    }
+
+    const result = await img;
+    console.log(`[HD-Profile] Output: ${result.length} bytes, dims preserved (max 720px)`);
+    return { img: result };
+};
 /** gets the SHA256 of the given media message */
 export const mediaMessageSHA256B64 = (message) => {
     const media = Object.values(message)[0];

package/lib/Utils/meta-compositing.js

@@ -1,13 +1,12 @@
 /**
  * Lia@Changes [WIP]
- * Meta Compositing — send rich messages (code, table, text, etc.) with a
- * Meta AI-style progress indicator that appears BEFORE the final message.
+ * Meta Compositing — send rich messages with Meta AI-style progress indicator.
  *
- * The progress placeholder is sent first (with BotProgressIndicatorMetadata),
- * then deleted, then the final rich message is sent fresh — so NO "edited"
- * badge ever appears. Identical to how Meta AI itself works.
+ * UNIVERSAL VERSION: Works on ALL WhatsApp clients.
+ *   - Native Meta AI rendering for compatible clients (Beta, AI-enabled)
+ *   - Plain text fallback for regular clients (no "Update WhatsApp")
  *
- * metaTyping() — shows the "typing..." / planning steps indicator only.
+ * metaTyping() — shows the "typing..." / planning steps indicator.
  * sendMetaComposited() — full flow: typing → delete → final message.
  *
  * If you use or copy this code, please credit @crysnovax/bailey.
@@ -19,18 +18,23 @@ import { BOT_RENDERING_CONFIG_METADATA } from '../Defaults/index.js';
 import { generateWAMessageFromContent } from './messages.js';
 import { unixTimestampSeconds, delay } from './generics.js';
 
-// ─── Step status enum mirrors proto.BotProgressIndicatorMetadata.BotPlanningStepMetadata status field ───
+// ─── Step status enum ───
 export const PlanningStepStatus = {
     IN_PROGRESS: 0,
     DONE: 1,
     FAILED: 2
 };
 
+/**
+ * Check if recipient supports native Meta AI rendering.
+ * Always false for now — WhatsApp hasn't opened this to third-party bots.
+ */
+export const supportsMetaRendering = (jid, config = {}) => {
+    return config.forceMetaRendering === true;
+};
+
 /**
  * Build a BotProgressIndicatorMetadata object.
- * @param {string} description   - Top-level label shown while "thinking"
- * @param {Array}  steps         - Array of { title, body?, status?, isReasoning? }
- * @param {number} estimatedMs   - Optional estimated completion time in ms
  */
 export const buildProgressIndicator = (description, steps = [], estimatedMs) => {
     const stepsMetadata = steps.map(step => {
@@ -51,27 +55,16 @@ export const buildProgressIndicator = (description, steps = [], estimatedMs) =>
 };
 
 /**
- * Build the compositing placeholder message — the one that shows the
- * "Meta AI is thinking..." / planning steps indicator in the chat bubble.
- *
- * This is a botForwardedMessage with richResponseMessage = null content
- * but with progressIndicatorMetadata on the botMetadata.
- *
- * @param {object} options
- * @param {string} options.description        - "Thinking…" label
- * @param {Array}  options.steps              - Planning steps array
- * @param {number} [options.estimatedMs]      - Estimated completion ms
- * @param {string} [options.placeholderText]  - Text shown in the bubble body while loading
+ * Build the native Meta AI compositing placeholder (for compatible clients only).
  */
 export const buildCompositingPlaceholder = ({
     description = 'Thinking…',
     steps = [],
     estimatedMs,
     placeholderText = ''
-}) => {
+} = {}) => {
     const progressIndicatorMetadata = buildProgressIndicator(description, steps, estimatedMs);
 
-    // Minimal richResponseMessage so the bubble renders in Bot mode
     const textEncoder = new TextEncoder();
     const unifiedData = textEncoder.encode(JSON.stringify({
         response_id: crypto.randomUUID(),
@@ -119,90 +112,81 @@ export const buildCompositingPlaceholder = ({
 };
 
 /**
- * metaTyping — sends ONLY the progress/compositing indicator to a JID.
- * Does NOT delete or send a follow-up — caller controls that.
- *
- * Returns the sent message key so you can delete it later.
- *
- * @param {object} sock       - Baileys socket
- * @param {string} jid        - Destination JID
- * @param {object} options    - Same options as buildCompositingPlaceholder
- * @returns {Promise<object>} - The sent WAMessage
+ * Build a plain-text placeholder that works on ALL WhatsApp clients.
+ */
+export const buildPlainPlaceholder = (description = 'Thinking…', steps = [], placeholderText = '') => {
+    const stepLines = steps.map(step => {
+        const icon = step.status === PlanningStepStatus.DONE ? '✓' :
+                     step.status === PlanningStepStatus.FAILED ? '✗' : '○';
+        return `${icon} ${step.title}`;
+    }).join('\n');
+
+    let text = `_${description}_`;
+    if (stepLines) text += `\n\n${stepLines}`;
+    if (placeholderText) text += `\n\n${placeholderText}`;
+
+    return { text };
+};
+
+/**
+ * metaTyping — sends the progress/compositing indicator.
+ * UNIVERSAL: Uses plain text for regular clients, native Meta AI for compatible ones.
  */
 export const metaTyping = async (sock, jid, {
     description = 'Thinking…',
     steps = [],
     estimatedMs,
-    placeholderText = ''
+    placeholderText = '',
+    useNativeMeta = false
 } = {}) => {
-    const placeholder = buildCompositingPlaceholder({
-        description,
-        steps,
-        estimatedMs,
-        placeholderText
-    });
+    // Show typing indicator
+    await sock.sendPresenceUpdate('composing', jid);
+
+    if (useNativeMeta && supportsMetaRendering(jid, sock.config)) {
+        const placeholder = buildCompositingPlaceholder({
+            description, steps, estimatedMs, placeholderText
+        });
+        return sock.sendMessage(jid, { raw: true, ...placeholder });
+    }
 
-    return sock.sendMessage(jid, { raw: true, ...placeholder });
+    // Universal fallback: plain text placeholder
+    const plainSteps = steps.map(s => ({ ...s, status: PlanningStepStatus.IN_PROGRESS }));
+    const placeholder = buildPlainPlaceholder(description, plainSteps, placeholderText);
+    return sock.sendMessage(jid, placeholder);
 };
 
 /**
- * sendMetaComposited — full Meta AI flow:
- *   1. Send progress indicator placeholder
- *   2. Wait `thinkingMs` (default 2000ms)
- *   3. Delete the placeholder (no "edited" badge ever appears)
- *   4. Send the final rich message fresh
- *
- * Supports all existing richResponse content types: text, code, table,
- * expressions (LaTeX), items (reels carousel), or the richResponse array.
- *
- * @param {object} sock            - Baileys socket
- * @param {string} jid             - Destination JID
- * @param {object} content         - Same content object as sendMessage richResponse
- * @param {object} [options]
- * @param {number} [options.thinkingMs=2000]          - How long placeholder shows
- * @param {string} [options.description='Thinking…']  - Placeholder label
- * @param {Array}  [options.steps=[]]                 - Planning steps to show
- * @param {string} [options.placeholderText='']       - Body text while loading
- * @param {object} [options.sendOptions={}]           - Extra options for final sendMessage
- * @returns {Promise<object>} - The final sent WAMessage
+ * sendMetaComposited — full Meta AI flow (UNIVERSAL).
+ *   1. Send progress indicator
+ *   2. Wait thinkingMs
+ *   3. Delete placeholder
+ *   4. Send final message fresh
  */
 export const sendMetaComposited = async (sock, jid, content, {
     thinkingMs = 2000,
     description = 'Thinking…',
     steps = [],
     placeholderText = '',
-    sendOptions = {}
+    sendOptions = {},
+    useNativeMeta = false
 } = {}) => {
-    // 1. Send the compositing placeholder
     const placeholder = await metaTyping(sock, jid, {
-        description,
-        steps,
-        placeholderText
+        description, steps, estimatedMs: thinkingMs, placeholderText, useNativeMeta
     });
 
     try {
-        // 2. Wait — this is the "thinking" window
         await delay(thinkingMs);
-
-        // 3. Delete the placeholder silently
         if (placeholder?.key) {
             await sock.sendMessage(jid, { delete: placeholder.key });
         }
-    } catch (_) {
-        // Non-fatal — always attempt final send
-    }
+    } catch (_) {}
 
-    // 4. Send the final rich message as a brand-new message (no edit = no badge)
+    await sock.sendPresenceUpdate('paused', jid);
     return sock.sendMessage(jid, content, sendOptions);
 };
 
 /**
- * Convenience: build a steps array from plain strings with IN_PROGRESS status.
- * Use PlanningStepStatus.DONE to mark a step complete.
- *
- * @example
- * buildSteps(['Searching…', 'Reading sources…', 'Writing response…'])
+ * Convenience: build a steps array from plain strings.
  */
 export const buildSteps = (titles, status = PlanningStepStatus.IN_PROGRESS) =>
     titles.map(title => ({ title, status }));
-

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@crysnovax/baileys",
-   "version": "2.6.1",
+   "version": "2.6.3",
    "description": "Premium Baileys fork ⚉ Meta compositing, bot planning replay, welcome flow, rich messages (code, table, LaTeX, reels), interactive messages, albums, and more.",
    "main": "lib/index.js",
    "type": "module",