@fer2809fl/baileys 7.0.4 → 7.0.5

package/lib/Socket/chats.d.ts

@@ -76,6 +76,20 @@ export declare const makeChatsSocket: (config: SocketConfig) => {
         id: string;
         fromMe?: boolean;
     }[], star: boolean) => Promise<void>;
+    /** Fija o desfija un chat en la parte superior de la lista de chats. */
+    pinChat: (jid: string, pin?: boolean) => Promise<void>;
+    /** Archiva o desarchiva un chat. */
+    archiveChat: (jid: string, archive?: boolean, lastMessages?: import("../Types/index.js").LastMessageList) => Promise<void>;
+    /** Silencia un chat hasta `muteEndTimestamp` (ms). Pasa `undefined` para quitar el silencio. */
+    muteChat: (jid: string, muteEndTimestamp?: number) => Promise<void>;
+    /** Marca un chat como leído (o no leído con `read: false`). */
+    markChatRead: (jid: string, read?: boolean, lastMessages?: import("../Types/index.js").LastMessageList) => Promise<void>;
+    /** Atajo para marcar un chat como no leído. */
+    markChatUnread: (jid: string, lastMessages?: import("../Types/index.js").LastMessageList) => Promise<void>;
+    /** Vacía el historial de un chat sin eliminar el chat. */
+    clearChat: (jid: string, lastMessages?: import("../Types/index.js").LastMessageList) => Promise<void>;
+    /** Elimina un chat completo de la lista de chats. */
+    deleteChat: (jid: string, lastMessages?: import("../Types/index.js").LastMessageList) => Promise<void>;
     addOrEditQuickReply: (quickReply: QuickReplyAction) => Promise<void>;
     removeQuickReply: (timestamp: string) => Promise<void>;
     type: "md";

package/lib/Socket/chats.js

@@ -547,6 +547,47 @@ export const makeChatsSocket = (config) => {
             onMutation(globalMutationMap[key]);
         }
     });
+    /**
+     * Fija o desfija un chat en la parte superior de la lista de chats.
+     */
+    const pinChat = (jid, pin = true) => {
+        return chatModify({ pin }, jid);
+    };
+    /**
+     * Archiva o desarchiva un chat. Si se pasan `lastMessages`, se usan para
+     * calcular el rango de mensajes que WhatsApp debe archivar/desarchivar.
+     */
+    const archiveChat = (jid, archive = true, lastMessages) => {
+        return chatModify({ archive, lastMessages }, jid);
+    };
+    /**
+     * Silencia un chat. `muteEndTimestamp` es el timestamp (ms) hasta el que
+     * estará silenciado; pasa `undefined`/`null` (o llama con `false`) para
+     * quitar el silencio.
+     */
+    const muteChat = (jid, muteEndTimestamp) => {
+        return chatModify({ mute: muteEndTimestamp || undefined }, jid);
+    };
+    /**
+     * Marca un chat como leído o no leído.
+     */
+    const markChatRead = (jid, read = true, lastMessages) => {
+        return chatModify({ markRead: read, lastMessages }, jid);
+    };
+    /** Atajo para marcar un chat como no leído. */
+    const markChatUnread = (jid, lastMessages) => markChatRead(jid, false, lastMessages);
+    /**
+     * Vacía el historial de un chat (sin eliminar el chat en sí).
+     */
+    const clearChat = (jid, lastMessages) => {
+        return chatModify({ clear: true, lastMessages }, jid);
+    };
+    /**
+     * Elimina un chat completo de la lista de chats.
+     */
+    const deleteChat = (jid, lastMessages) => {
+        return chatModify({ delete: true, lastMessages }, jid);
+    };
     /**
      * fetch the profile picture of a user/group
      * type = "preview" for a low res picture
@@ -1191,6 +1232,13 @@ export const makeChatsSocket = (config) => {
         addMessageLabel,
         removeMessageLabel,
         star,
+        pinChat,
+        archiveChat,
+        muteChat,
+        markChatRead,
+        markChatUnread,
+        clearChat,
+        deleteChat,
         addOrEditQuickReply,
         removeQuickReply
     };

package/lib/Socket/index.d.ts

@@ -293,6 +293,23 @@ declare const makeWASocket: (config: UserFacingSocketConfig) => {
     message: any;
     messageId: string;
   }>;
+  /**
+   * Envía un mensaje HTML embebido en WhatsApp. El cliente lo renderiza como
+   * un WebView sandboxed dentro del bocadillo del mensaje, usando el campo
+   * interno `GenAIaeacdsnwHtmlPrimitive` del protocolo AIRichResponseMessage.
+   *
+   * Ver `HtmlContentOptions` y el README para limitaciones y patrón recomendado.
+   */
+  sendHtml: (
+    jid: string,
+    html: string,
+    trustedSources?: string[],
+    quoted?: any,
+    options?: import("../Utils/rich-messages.js").HtmlContentOptions,
+  ) => Promise<{
+    message: any;
+    messageId: string;
+  }>;
   sendMessage: (
     jid: string,
     content: import("../index.js").AnyMessageContent,

package/lib/Socket/messages-send.d.ts

@@ -23,6 +23,7 @@ import {
   type LatexRenderFn,
   type MediaUploadFn,
   type CapturedUnifiedResponse,
+  type HtmlContentOptions,
 } from "../Utils/rich-messages.js";
 import { type BinaryNode, type JidWithDevice } from "../WABinary/index.js";
 import { USyncQuery } from "../WAUSync/index.js";
@@ -235,6 +236,23 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
     message: any;
     messageId: string;
   }>;
+  /**
+   * Envía un mensaje HTML embebido en WhatsApp. El cliente lo renderiza como
+   * un WebView sandboxed dentro del bocadillo del mensaje, usando el campo
+   * interno `GenAIaeacdsnwHtmlPrimitive` del protocolo AIRichResponseMessage.
+   *
+   * Ver `HtmlContentOptions` y el README para limitaciones y patrón recomendado.
+   */
+  sendHtml: (
+    jid: string,
+    html: string,
+    trustedSources?: string[],
+    quoted?: any,
+    options?: HtmlContentOptions,
+  ) => Promise<{
+    message: any;
+    messageId: string;
+  }>;
   sendMessage: (
     jid: string,
     content: AnyMessageContent,

package/lib/Socket/messages-send.js

@@ -39,6 +39,7 @@ import {
   generateLatexInlineImageContent,
   generateUnifiedResponseContent,
   captureUnifiedResponse,
+  generateHtmlContent,
 } from "../Utils/rich-messages.js";
 import { getUrlInfo } from "../Utils/link-preview.js";
 import { makeKeyedMutex } from "../Utils/make-mutex.js";
@@ -1022,8 +1023,11 @@ export const makeMessagesSocket = (config) => {
       }
       const buttonType = getButtonType(message);
       if (buttonType && !isNewsletter && !isStatus) {
-        const bizNodes = getAdditionalNode(buttonType);
-        stanza.content.push(...bizNodes);
+        const hasBizNode = stanza.content.some((node) => typeof node === "object" && node && node.tag === "biz");
+        if (!hasBizNode) {
+          const bizNodes = getAdditionalNode(buttonType);
+          stanza.content.push(...bizNodes);
+        }
       }
       logger.debug(
         { msgId },
@@ -1428,6 +1432,50 @@ export const makeMessagesSocket = (config) => {
       await relayMessage(jid, message, { messageId });
       return { message, messageId };
     },
+    /**
+     * Envía un mensaje que el cliente de WhatsApp renderiza como un WebView
+     * embebido dentro del bocadillo del mensaje.
+     *
+     * El HTML vive dentro de `unifiedResponse.data` y es renderizado por el
+     * cliente usando el campo interno `GenAIaeacdsnwHtmlPrimitive` del
+     * protocolo AIRichResponseMessage. El WebView puede hacer fetch únicamente
+     * a los dominios listados en `trustedSources`.
+     *
+     * @param {string} jid - JID del chat destino.
+     * @param {string} html - Contenido HTML (con `<style>`, `<body>`, `<script>`).
+     * @param {string[]} trustedSources - Dominios permitidos para fetch/recursos.
+     * @param {object} quoted - Mensaje a responder (opcional).
+     * @param {object} options - Opciones adicionales (headerText, footer, fallbackText).
+     * @returns {Promise<{ message: any, messageId: string }>}
+     *
+     * @example
+     * ```js
+     * await sock.sendHtml(
+     *   jid,
+     *   `<body><h1>Hola</h1></body>`,
+     *   ["api.tuyo.com"],
+     *   msg,
+     *   { headerText: "Demo HTML" }
+     * );
+     * ```
+     *
+     * Ver README sección "HTML embebido en WhatsApp" para limitaciones
+     * estructurales y patrón recomendado (backend + JWT + inyección de estado).
+     */
+    sendHtml: async (
+      jid,
+      html,
+      trustedSources = [],
+      quoted,
+      options = {},
+    ) => {
+      const { message, messageId } = generateHtmlContent(html, quoted, {
+        ...options,
+        trustedSources,
+      });
+      await relayMessage(jid, message, { messageId });
+      return { message, messageId };
+    },
     sendMessage: async (jid, content, options = {}) => {
       const userJid = authState.creds.me.id;
       const { quoted } = options;

package/lib/Utils/anti-ban.d.ts

@@ -0,0 +1,41 @@
+export declare const ANTI_BAN_CONFIG: {
+    MIN_MESSAGE_DELAY: number;
+    MAX_MESSAGE_DELAY: number;
+    MIN_TYPING_DELAY: number;
+    MAX_TYPING_DELAY: number;
+    GROUP_MESSAGE_DELAY: number;
+    GROUP_MAX_MESSAGES_PER_MINUTE: number;
+    BROADCAST_DELAY: number;
+    BROADCAST_MAX_PER_HOUR: number;
+    PRESENCE_UPDATE_INTERVAL: number;
+    JITTER_PERCENT: number;
+};
+
+export declare function randomDelay(min: number, max: number): number;
+export declare function messageDelay(isGroup?: boolean): Promise<void>;
+export declare function typingDelay(messageLength?: number): Promise<void>;
+
+export declare class RateLimiter {
+    constructor(maxRequests: number, windowMs: number);
+    canSend(jid?: string): boolean;
+    recordSend(jid?: string): void;
+    getWaitTime(jid?: string): number;
+    waitForSlot(jid?: string): Promise<void>;
+    cleanup(): void;
+}
+
+export declare class PresenceManager {
+    constructor(sock: any, logger?: any);
+    simulatePresence(jid: string, action?: 'composing' | 'recording' | 'paused' | 'available' | 'unavailable'): Promise<void>;
+    sendWithPresence<T = any>(jid: string, sendFunc: () => Promise<T>, messageContent: string | object): Promise<T>;
+    startPeriodicPresence(): void;
+    stopPeriodicPresence(): void;
+}
+
+export declare function generateSessionFingerprint(): string;
+export declare function isValidJid(jid: string): boolean;
+export declare function sanitizeMessage(text: string): string;
+
+export declare const globalRateLimiter: RateLimiter;
+export declare const groupRateLimiter: RateLimiter;
+export declare const broadcastRateLimiter: RateLimiter;

package/lib/Utils/anti-ban.js

@@ -0,0 +1,182 @@
+import { randomBytes } from 'crypto';
+
+const ANTI_BAN_CONFIG = {
+    MIN_MESSAGE_DELAY: 300,
+    MAX_MESSAGE_DELAY: 800,
+    MIN_TYPING_DELAY: 500,
+    MAX_TYPING_DELAY: 1500,
+    GROUP_MESSAGE_DELAY: 500,
+    GROUP_MAX_MESSAGES_PER_MINUTE: 40,
+    BROADCAST_DELAY: 1500,
+    BROADCAST_MAX_PER_HOUR: 300,
+    PRESENCE_UPDATE_INTERVAL: 30000,
+    JITTER_PERCENT: 0.3
+};
+
+function randomDelay(min, max) {
+    const base = Math.floor(Math.random() * (max - min + 1)) + min;
+    const jitter = base * ANTI_BAN_CONFIG.JITTER_PERCENT * (Math.random() - 0.5);
+    return Math.max(min, Math.floor(base + jitter));
+}
+
+async function messageDelay(isGroup = false) {
+    const delay = isGroup
+        ? randomDelay(ANTI_BAN_CONFIG.GROUP_MESSAGE_DELAY, ANTI_BAN_CONFIG.GROUP_MESSAGE_DELAY * 2)
+        : randomDelay(ANTI_BAN_CONFIG.MIN_MESSAGE_DELAY, ANTI_BAN_CONFIG.MAX_MESSAGE_DELAY);
+    return new Promise(resolve => setTimeout(resolve, delay));
+}
+
+async function typingDelay(messageLength = 50) {
+    const wordsPerMinute = 50 + (Math.random() * 20 - 10);
+    const avgWordLength = 5;
+    const estimatedWords = messageLength / avgWordLength;
+    const typingTime = (estimatedWords / wordsPerMinute) * 60 * 1000;
+    const minDelay = ANTI_BAN_CONFIG.MIN_TYPING_DELAY;
+    const calculatedDelay = Math.max(minDelay, Math.min(typingTime, ANTI_BAN_CONFIG.MAX_TYPING_DELAY));
+    return new Promise(resolve => setTimeout(resolve, calculatedDelay));
+}
+
+class RateLimiter {
+    constructor(maxRequests, windowMs) {
+        this.maxRequests = maxRequests;
+        this.windowMs = windowMs;
+        this.requests = new Map();
+    }
+
+    canSend(jid) {
+        const now = Date.now();
+        const key = jid || 'global';
+        if (!this.requests.has(key)) this.requests.set(key, []);
+        const timestamps = this.requests.get(key);
+        const validTimestamps = timestamps.filter(ts => now - ts < this.windowMs);
+        this.requests.set(key, validTimestamps);
+        return validTimestamps.length < this.maxRequests;
+    }
+
+    recordSend(jid) {
+        const key = jid || 'global';
+        if (!this.requests.has(key)) this.requests.set(key, []);
+        this.requests.get(key).push(Date.now());
+    }
+
+    getWaitTime(jid) {
+        const key = jid || 'global';
+        if (!this.requests.has(key)) return 0;
+        const timestamps = this.requests.get(key);
+        if (timestamps.length < this.maxRequests) return 0;
+        const oldestValid = timestamps[timestamps.length - this.maxRequests];
+        const waitTime = this.windowMs - (Date.now() - oldestValid);
+        return Math.max(0, waitTime);
+    }
+
+    async waitForSlot(jid) {
+        const waitTime = this.getWaitTime(jid);
+        if (waitTime > 0) {
+            await new Promise(resolve => setTimeout(resolve, waitTime + randomDelay(100, 500)));
+        }
+        this.recordSend(jid);
+    }
+
+    cleanup() {
+        const now = Date.now();
+        for (const [key, timestamps] of this.requests.entries()) {
+            const valid = timestamps.filter(ts => now - ts < this.windowMs);
+            if (valid.length === 0) this.requests.delete(key);
+            else this.requests.set(key, valid);
+        }
+    }
+}
+
+class PresenceManager {
+    constructor(sock, logger) {
+        this.sock = sock;
+        this.logger = logger;
+        this.activeChats = new Set();
+        this.presenceInterval = null;
+    }
+
+    async simulatePresence(jid, action = 'composing') {
+        try {
+            await this.sock.sendPresenceUpdate(action, jid);
+            this.activeChats.add(jid);
+            setTimeout(() => {
+                this.activeChats.delete(jid);
+                this.sock.sendPresenceUpdate('paused', jid).catch(() => {});
+            }, randomDelay(3000, 8000));
+        } catch (error) {
+            this.logger?.debug({ error }, 'Error updating presence');
+        }
+    }
+
+    async sendWithPresence(jid, sendFunc, messageContent) {
+        await this.simulatePresence(jid, 'composing');
+        const length = typeof messageContent === 'string'
+            ? messageContent.length
+            : JSON.stringify(messageContent).length;
+        await typingDelay(length);
+        const result = await sendFunc();
+        setTimeout(() => {
+            this.sock.sendPresenceUpdate('paused', jid).catch(() => {});
+        }, randomDelay(500, 1500));
+        return result;
+    }
+
+    startPeriodicPresence() {
+        if (this.presenceInterval) return;
+        this.presenceInterval = setInterval(() => {
+            this.sock.sendPresenceUpdate('available').catch(() => {});
+        }, ANTI_BAN_CONFIG.PRESENCE_UPDATE_INTERVAL);
+    }
+
+    stopPeriodicPresence() {
+        if (this.presenceInterval) {
+            clearInterval(this.presenceInterval);
+            this.presenceInterval = null;
+        }
+    }
+}
+
+function generateSessionFingerprint() {
+    const timestamp = Date.now();
+    const random = randomBytes(8).toString('hex');
+    return `${timestamp}-${random}`;
+}
+
+function isValidJid(jid) {
+    if (!jid || typeof jid !== 'string') return false;
+    const patterns = [
+        /^\d+@s\.whatsapp\.net$/,
+        /^\d+-\d+@g\.us$/,
+        /^\d+@broadcast$/,
+        /^status@broadcast$/,
+        /^\d+@lid$/
+    ];
+    return patterns.some(pattern => pattern.test(jid));
+}
+
+function sanitizeMessage(text) {
+    if (!text || typeof text !== 'string') return text;
+    let sanitized = text.replace(/[\u200B-\u200D\uFEFF]/g, '');
+    sanitized = sanitized.replace(/\n{4,}/g, '\n\n\n');
+    sanitized = sanitized.replace(/ {3,}/g, '  ');
+    return sanitized.trim();
+}
+
+const globalRateLimiter = new RateLimiter(100, 60000);
+const groupRateLimiter = new RateLimiter(20, 60000);
+const broadcastRateLimiter = new RateLimiter(200, 3600000);
+
+export {
+    ANTI_BAN_CONFIG,
+    randomDelay,
+    messageDelay,
+    typingDelay,
+    RateLimiter,
+    PresenceManager,
+    generateSessionFingerprint,
+    isValidJid,
+    sanitizeMessage,
+    globalRateLimiter,
+    groupRateLimiter,
+    broadcastRateLimiter
+};

package/lib/Utils/banner.d.ts

@@ -0,0 +1,8 @@
+export declare const BAILEYS_LOGO: string[];
+
+export declare function printBanner(options?: {
+    stream?: NodeJS.WritableStream;
+    frameMs?: number;
+    once?: boolean;
+    animate?: boolean;
+}): Promise<void>;

package/lib/Utils/banner.js

@@ -0,0 +1,76 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+const BAILEYS_LOGO = [
+    '               ⠠⡀ ⡀',
+    '              ⠱⣄⠘⣆',
+    '      ⣀  ⢢⣤⣀⣦⣄⡀⠙⣶⡘⢷⣄',
+    '    ⣀⣀⣨⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣯⣿⣷⣄',
+    '   ⢀⣽⣿⣿⣿⣿⠟⠛⠛⠛⠛⠻⢿⣿⣿⣿⣿⣿⣿⣷⣄',
+    '  ⠘⣻⣿⣿⡿⠋        ⠈⠙⢿⣿⣿⣿⣿⢿⣷⡀',
+    '  ⣴⣿⣿⣿⡇            ⠙⣿⣿⣿⣷⣽⣷⣄',
+    '   ⣾⣿⣿⣇             ⠈⠛⢿⣿⣿⣿⣯⠁',
+    '  ⠐⠛⢿⣿⣿⣦⡀              ⠉⠻⣿⣿⣷⣄⡀',
+    '    ⠘⠟⠿⣿⣿⣦⣀              ⠈⢿⣿⣿⠇',
+    '       ⠈⠙⠻⣿⣷⣦⣄⡀           ⡼⠟⠋',
+    '           ⠈⠙⠻⢿⣷⣶⣄',
+    '               ⠈⠙⠻⣿⣦⡀',
+    '                   ⠙⢿⡄',
+    '                     ⢻⡄',
+    '                     ⠈⡇'
+];
+
+const GRADIENT_FROM = [167, 85, 247];
+const GRADIENT_TO = [34, 211, 238];
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const supportsColor = stream => {
+    if (process.env.NO_COLOR || process.env.NODE_DISABLE_COLORS) return false;
+    if (process.env.FORCE_COLOR) return true;
+    return !!stream.isTTY;
+};
+
+const paint = (text, t) => {
+    const [r, g, b] = GRADIENT_FROM.map((from, i) => Math.round(from + (GRADIENT_TO[i] - from) * t));
+    return `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+};
+
+const buildLines = version => [
+    '',
+    ...BAILEYS_LOGO,
+    '',
+    `   @fer2809fl/baileys   v${version}`,
+    '   github.com/Fer2809fl/Bail',
+    ''
+];
+
+let alreadyPrinted = false;
+
+const printBanner = async (options = {}) => {
+    let version = '2.0';
+    try {
+        const pkg = JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf8'));
+        version = pkg.version || version;
+    } catch {}
+    const {
+        stream = process.stdout,
+        frameMs = 45,
+        once = true
+    } = options;
+    if (once && alreadyPrinted) return;
+    alreadyPrinted = true;
+    const animate = options.animate !== undefined ? options.animate : !!stream.isTTY;
+    const color = supportsColor(stream);
+    const lines = buildLines(version);
+    for (let i = 0; i < lines.length; i++) {
+        const t = i / (lines.length - 1);
+        stream.write((color ? paint(lines[i], t) : lines[i]) + '\n');
+        if (animate) await sleep(frameMs);
+    }
+};
+
+export {
+    BAILEYS_LOGO,
+    printBanner
+};

package/lib/Utils/bot-utils.d.ts

@@ -0,0 +1,57 @@
+export declare function parseCommand(text: string, prefix?: string): {
+    isCommand: boolean;
+    command?: string;
+    args?: string[];
+    fullArgs?: string;
+    flags?: Record<string, string | boolean>;
+    raw?: string;
+    prefix?: string;
+};
+
+export declare function extractMentions(message: any): string[];
+export declare function extractText(message: any): string;
+export declare function extractQuotedMessage(message: any): {
+    message: any;
+    stanzaId?: string;
+    participant?: string;
+    remoteJid?: string;
+    text: string;
+} | null;
+
+export declare function isGroupAdmin(sock: any, jid: string, participantJid: string): Promise<boolean>;
+export declare function isBotAdmin(sock: any, jid: string): Promise<boolean>;
+export declare function getSenderJid(msg: any): string;
+export declare function formatJid(jid: string): string;
+export declare function generateMessageId(): string;
+export declare function truncateText(text: string, maxLength?: number, suffix?: string): string;
+export declare function escapeMarkdown(text: string): string;
+export declare function formatPhoneNumber(jid: string): string;
+
+export declare class CooldownManager {
+    isOnCooldown(key: string, cooldownMs: number): boolean;
+    setCooldown(key: string, cooldownMs: number): void;
+    getRemainingTime(key: string): number;
+    cleanup(): void;
+}
+
+export declare class PermissionManager {
+    constructor(config?: { owners?: string[]; admins?: string[]; banned?: string[]; premiums?: string[] });
+    isOwner(jid: string): boolean;
+    isAdmin(jid: string): boolean;
+    isBanned(jid: string): boolean;
+    isPremium(jid: string): boolean;
+    addOwner(jid: string): void;
+    removeOwner(jid: string): void;
+    addAdmin(jid: string): void;
+    removeAdmin(jid: string): void;
+    ban(jid: string): void;
+    unban(jid: string): void;
+    addPremium(jid: string): void;
+    removePremium(jid: string): void;
+    toJSON(): { owners: string[]; admins: string[]; banned: string[]; premiums: string[] };
+}
+
+export declare function createReply(options: { text: string; mentions?: string[]; quoted?: any }): { text: string; mentions?: string[]; quoted?: any };
+export declare function parseTime(timeStr: string): number;
+export declare function formatDuration(ms: number): string;
+export declare function sendFast(sock: any, jid: string, content: string | object, opts?: { quoted?: any; markRead?: boolean }): Promise<any>;