@crysnovax/baileys 2.6.0 → 2.6.2

package/lib/Utils/bot-planning-replay.js

@@ -2,22 +2,17 @@
  * Lia@Changes [WIP]
  * botPlanningReplay — Meta AI-style live reasoning feed.
  *
- * Sends a progress indicator with all steps IN_PROGRESS, then replays
- * each step completing in real time via sequential edits — exactly how
- * Meta AI's "Thinking…" bubble works. Final rich message lands clean
- * with NO "edited" badge, using the same delete-resend flow from
- * meta-compositing.
- *
- *   replayPlanning(sock, jid, steps, finalContent, options)
+ * UNIVERSAL VERSION: Works on ALL WhatsApp clients.
+ *   - Native Meta AI rendering for compatible clients
+ *   - Plain text fallback for regular clients (no "Update WhatsApp")
  *
  * Flow:
- *   Send placeholder (all steps IN_PROGRESS)
- *     → edit: step[0] → DONE  (stepDelayMs)
- *     → edit: step[1] → DONE  (stepDelayMs)
+ *   Send placeholder (all steps pending)
+ *     → edit: step[0] → DONE
+ *     → edit: step[1] → DONE
  *     → ...
- *     → edit: step[n] → DONE  (finalPauseMs)
  *     → delete placeholder
- *     → send final rich message fresh
+ *     → send final message fresh
  *
  * If you use or copy this code, please credit @crysnovax/bailey.
  */
@@ -26,46 +21,32 @@ import { proto } from '../../WAProto/index.js';
 import {
     buildCompositingPlaceholder,
     buildProgressIndicator,
+    buildPlainPlaceholder,
     PlanningStepStatus
 } from './meta-compositing.js';
 import { botMetadataSignature, botMetadataCertificate } from './rich-message-utils.js';
 import { BOT_RENDERING_CONFIG_METADATA } from '../Defaults/index.js';
 import { delay } from './generics.js';
 
-// ─── Internal: rebuild the full botForwardedMessage with updated step statuses ───────────────
+// ─── Internal: build native Meta AI frame ──────────────────────────────────
 const buildReplayFrame = (description, steps, placeholderText = '') => {
     return buildCompositingPlaceholder({ description, steps, placeholderText });
 };
 
-// ─── Internal: send an in-place edit of the planning bubble with new step states ─────────────
+// ─── Internal: edit planning bubble (native Meta AI) ───────────────────────
 const editPlanningBubble = async (sock, jid, key, description, steps, placeholderText) => {
     const updated = buildReplayFrame(description, steps, placeholderText);
-    // Use { edit: key, raw: true } — routes through protocolMessage.editedMessage
-    await sock.sendMessage(jid, {
-        raw: true,
-        edit: key,
-        ...updated
-    });
+    await sock.sendMessage(jid, { raw: true, edit: key, ...updated });
+};
+
+// ─── Internal: edit plain text bubble (universal) ──────────────────────────
+const editPlainBubble = async (sock, jid, key, description, steps, placeholderText) => {
+    const updated = buildPlainPlaceholder(description, steps, placeholderText);
+    await sock.sendMessage(jid, { edit: key, ...updated });
 };
 
 /**
- * replayPlanning — full live planning animation.
- *
- * @param {object}   sock                        - Baileys socket
- * @param {string}   jid                         - Destination JID
- * @param {Array}    steps                        - Array of step definitions:
- *                                                  { title, body?, isReasoning?, isEnhancedSearch? }
- *                                                  Status is managed automatically — do NOT pass status here.
- * @param {object}   finalContent                 - Rich content for the final message.
- *                                                  Same as sendMessage: { code, table, text, richResponse… }
- * @param {object}   [options]
- * @param {string}   [options.description]        - Top label while thinking. Default: 'Thinking…'
- * @param {string}   [options.placeholderText]    - Body text shown in bubble while loading.
- * @param {number}   [options.stepDelayMs]        - Ms between each step completing. Default: 900
- * @param {number}   [options.finalPauseMs]       - Ms to hold after all steps done before cleanup. Default: 600
- * @param {boolean}  [options.abortOnDisconnect]  - Stop replay loop if socket closes. Default: true
- * @param {object}   [options.sendOptions]        - Extra options for final sendMessage call.
- * @returns {Promise<object>} - The final sent WAMessage
+ * replayPlanning — full live planning animation (UNIVERSAL).
  */
 export const replayPlanning = async (sock, jid, steps, finalContent, {
     description = 'Thinking…',
@@ -73,13 +54,13 @@ export const replayPlanning = async (sock, jid, steps, finalContent, {
     stepDelayMs = 900,
     finalPauseMs = 600,
     abortOnDisconnect = true,
-    sendOptions = {}
+    sendOptions = {},
+    useNativeMeta = false
 } = {}) => {
     if (!steps?.length) {
         throw new Error('replayPlanning: steps array must have at least one entry');
     }
 
-    // ── Track abort state if socket disconnects mid-replay ───────────────────
     let aborted = false;
     const onClose = () => { aborted = true; };
     if (abortOnDisconnect) {
@@ -88,112 +69,96 @@ export const replayPlanning = async (sock, jid, steps, finalContent, {
         });
     }
 
-    // ── 1. Build initial state — all steps IN_PROGRESS ───────────────────────
+    // Show typing
+    await sock.sendPresenceUpdate('composing', jid);
+
+    // Build initial steps (all pending)
     const initialSteps = steps.map(step => ({
         ...step,
         status: PlanningStepStatus.IN_PROGRESS
     }));
 
-    const placeholder = await sock.sendMessage(jid, {
-        raw: true,
-        ...buildReplayFrame(description, initialSteps, placeholderText)
-    });
+    // Determine mode
+    const isNative = useNativeMeta && false; // Always false for now — force universal
+
+    // Send initial placeholder
+    let placeholder;
+    if (isNative) {
+        placeholder = await sock.sendMessage(jid, {
+            raw: true,
+            ...buildReplayFrame(description, initialSteps, placeholderText)
+        });
+    } else {
+        placeholder = await sock.sendMessage(jid,
+            buildPlainPlaceholder(description, initialSteps, placeholderText)
+        );
+    }
 
     const key = placeholder?.key;
 
-    // ── 2. Replay loop — flip each step to DONE sequentially ─────────────────
+    // Replay loop
     try {
         const currentSteps = [...initialSteps];
 
         for (let i = 0; i < currentSteps.length; i++) {
             if (aborted) break;
-
             await delay(stepDelayMs);
             if (aborted) break;
 
-            // Flip this step to DONE
-            currentSteps[i] = {
-                ...currentSteps[i],
-                status: PlanningStepStatus.DONE
-            };
+            currentSteps[i] = { ...currentSteps[i], status: PlanningStepStatus.DONE };
 
             if (key) {
-                await editPlanningBubble(
-                    sock, jid, key,
-                    description, currentSteps, placeholderText
-                );
+                if (isNative) {
+                    await editPlanningBubble(sock, jid, key, description, currentSteps, placeholderText);
+                } else {
+                    await editPlainBubble(sock, jid, key, description, currentSteps, placeholderText);
+                }
             }
         }
 
-        // ── 3. Hold with all steps DONE so user sees completion ──────────────
         if (!aborted && finalPauseMs > 0) {
             await delay(finalPauseMs);
         }
 
-        // ── 4. Delete placeholder silently ───────────────────────────────────
         if (key && !aborted) {
             await sock.sendMessage(jid, { delete: key });
         }
     } catch (err) {
-        // Non-fatal — always attempt final send even if replay failed mid-way
-        try {
-            if (key) await sock.sendMessage(jid, { delete: key });
-        } catch (_) {}
+        try { if (key) await sock.sendMessage(jid, { delete: key }); } catch (_) {}
     }
 
-    // ── 5. Send the final rich message as a brand-new message — no edited badge ──
+    await sock.sendPresenceUpdate('paused', jid);
+
+    // Skip final send if _skipFinalSend is set (for replayPlanningOnly)
+    if (sendOptions._skipFinalSend) return placeholder;
+
     return sock.sendMessage(jid, finalContent, sendOptions);
 };
 
 /**
- * replayPlanningOnly — same animation but WITHOUT sending a final message.
- * Use when you want to control the final send yourself.
- *
- * Returns { key } of the placeholder (already deleted on completion).
- *
- * @param {object} sock
- * @param {string} jid
- * @param {Array}  steps
- * @param {object} [options]   - Same options as replayPlanning minus sendOptions
- * @returns {Promise<void>}
+ * replayPlanningOnly — animation WITHOUT final message.
  */
 export const replayPlanningOnly = async (sock, jid, steps, options = {}) => {
     return replayPlanning(sock, jid, steps, null, {
         ...options,
-        _skipFinalSend: true
+        sendOptions: { ...options.sendOptions, _skipFinalSend: true }
     });
 };
 
 /**
- * buildReasoningSteps — convenience builder for steps with isReasoning: true.
- * Renders with the "reasoning" visual treatment in the Meta bubble.
- *
- * @example
- * buildReasoningSteps(['Analyzing the problem…', 'Checking edge cases…'])
+ * buildReasoningSteps — steps with isReasoning: true.
  */
 export const buildReasoningSteps = (titles) =>
     titles.map(title => ({ title, isReasoning: true }));
 
 /**
- * buildSearchSteps — convenience builder for steps with isEnhancedSearch: true.
- * Renders with the "enhanced search" visual treatment.
- *
- * @example
- * buildSearchSteps(['Searching the web…', 'Reading top results…'])
+ * buildSearchSteps — steps with isEnhancedSearch: true.
  */
 export const buildSearchSteps = (titles) =>
     titles.map(title => ({ title, isEnhancedSearch: true }));
 
 /**
- * mixedSteps — build a steps array mixing reasoning + search + plain steps.
- * Pass an array of { title, type? } where type is 'reasoning' | 'search' | undefined.
- *
- * @example
- * mixedSteps([
- *   { title: 'Understanding your question…', type: 'reasoning' },
- *   { title: 'Searching for data…',          type: 'search' },
- *   { title: 'Writing the answer…' }
- * ])
+ * mixedSteps — mix reasoning + search + plain steps.
  */
 export const mixedSteps = (defs) =>
     defs.map(({ title, body, type }) => ({

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];