@fer2809fl/baileys 7.0.4 → 7.0.5

package/lib/Utils/rich-messages.js

@@ -170,6 +170,55 @@ export const BASH_KEYWORDS = new Set([
   "declare",
   "typeset",
 ]);
+// -- Añadido en v7.0.5: mas lenguajes soportados para resaltado de código (portado desde el fork beta) --
+export const RUST_KEYWORDS = new Set([
+  "as", "async", "await", "break", "const", "continue", "crate", "dyn", "else",
+  "enum", "extern", "false", "fn", "for", "if", "impl", "in", "let", "loop",
+  "match", "mod", "move", "mut", "pub", "ref", "return", "self", "Self",
+  "static", "struct", "super", "trait", "true", "type", "unsafe", "use",
+  "where", "while",
+]);
+export const C_KEYWORDS = new Set([
+  "auto", "break", "case", "char", "const", "continue", "default", "do",
+  "double", "else", "enum", "extern", "float", "for", "goto", "if", "inline",
+  "int", "long", "register", "restrict", "return", "short", "signed",
+  "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned",
+  "void", "volatile", "while",
+]);
+export const CPP_KEYWORDS = new Set([
+  ...C_KEYWORDS, "alignas", "alignof", "and", "asm", "bool", "catch", "class",
+  "concept", "consteval", "constexpr", "constinit", "const_cast", "co_await",
+  "co_return", "co_yield", "decltype", "delete", "dynamic_cast", "explicit",
+  "export", "friend", "mutable", "namespace", "new", "noexcept", "not",
+  "nullptr", "operator", "private", "protected", "public", "reinterpret_cast",
+  "requires", "static_assert", "static_cast", "template", "this",
+  "thread_local", "throw", "true", "try", "typeid", "typename", "using",
+  "virtual", "wchar_t",
+]);
+export const CSHARP_KEYWORDS = new Set([
+  "abstract", "as", "base", "bool", "break", "byte", "case", "catch", "char",
+  "checked", "class", "const", "continue", "decimal", "default", "delegate",
+  "do", "double", "else", "enum", "event", "explicit", "extern", "false",
+  "finally", "fixed", "float", "for", "foreach", "goto", "if", "implicit",
+  "in", "int", "interface", "internal", "is", "lock", "long", "namespace",
+  "new", "null", "object", "operator", "out", "override", "params", "private",
+  "protected", "public", "readonly", "ref", "return", "sbyte", "sealed",
+  "short", "sizeof", "stackalloc", "static", "string", "struct", "switch",
+  "this", "throw", "true", "try", "typeof", "uint", "ulong", "unchecked",
+  "unsafe", "ushort", "using", "var", "virtual", "void", "volatile", "while",
+]);
+export const HTML_KEYWORDS = new Set([
+  "DOCTYPE", "html", "head", "body", "div", "span", "p", "a", "h1", "h2",
+  "h3", "h4", "h5", "h6", "ul", "ol", "li", "table", "tr", "td", "th", "form",
+  "input", "button", "select", "option", "textarea", "img", "video", "audio",
+  "source", "canvas", "svg", "script", "style", "link", "meta", "title",
+]);
+export const CSS_KEYWORDS = new Set([
+  "color", "background", "margin", "padding", "border", "display",
+  "position", "width", "height", "font", "text", "align", "flex", "grid",
+  "animation", "transition", "transform", "opacity", "overflow", "cursor",
+  "z-index",
+]);
 export const LANGUAGE_KEYWORDS = {
   javascript: JS_KEYWORDS,
   typescript: JS_KEYWORDS,
@@ -183,6 +232,15 @@ export const LANGUAGE_KEYWORDS = {
   bash: BASH_KEYWORDS,
   sh: BASH_KEYWORDS,
   shell: BASH_KEYWORDS,
+  zsh: BASH_KEYWORDS,
+  rust: RUST_KEYWORDS,
+  c: C_KEYWORDS,
+  cpp: CPP_KEYWORDS,
+  "c++": CPP_KEYWORDS,
+  csharp: CSHARP_KEYWORDS,
+  "c#": CSHARP_KEYWORDS,
+  html: HTML_KEYWORDS,
+  css: CSS_KEYWORDS,
 };
 export var CodeHighlightType;
 (function (CodeHighlightType) {
@@ -1141,4 +1199,131 @@ export const generateLinkContentV2 = (text, links, quoted, options = {}) => {
     messageId: generateMessageIDV2(),
   };
 };
+
+/**
+ * Construye un mensaje que el cliente de WhatsApp renderiza como un WebView
+ * embebido dentro del bocadillo del mensaje, usando el campo interno
+ * `GenAIaeacdsnwHtmlPrimitive` del protocolo AIRichResponseMessage.
+ *
+ * El HTML vive dentro de `unifiedResponse.data` (bytes opacos para el protocolo
+ * protobuf, pero parseados como JSON por el cliente de WhatsApp). El cliente
+ * levanta un WebView sandboxed y le permite hacer fetch únicamente a los
+ * dominios listados en `trustedSources`.
+ *
+ * Limitaciones estructurales conocidas (ver README sección "HTML embebido"):
+ *  - El WebView es efímero: NO confíes en `localStorage` para persistencia
+ *    entre sesiones. Mové la persistencia a un backend HTTP listado en
+ *    `trustedSources`.
+ *  - No existe un puente HTML → bot: el HTML no puede disparar eventos
+ *    directos al bot. Usá `fetch()` a tu backend y que el backend llame
+ *    `sock.sendMessage(...)` si necesitas reaccionar.
+ *  - El HTML no recibe identidad del usuario automáticamente: inyectá
+ *    `window.__INITIAL__ = { jid, token, ... }` al renderizar desde el bot.
+ *
+ * @param {string} html - Contenido HTML (con `<style>`, `<body>`, `<script>`).
+ * @param {object} quoted - Mensaje al que responder (opcional).
+ * @param {object} options - Opciones adicionales.
+ * @param {string[]} options.trustedSources - Dominios que el WebView puede
+ *   contactar (fetch, imágenes, fuentes, etc.). Sin esquema (ej: "api.tuyo.com").
+ * @param {string} options.headerText - Texto opcional arriba del HTML.
+ * @param {string} options.footer - Texto opcional debajo del HTML.
+ * @param {string} options.fallbackText - Texto mostrado en el submessage de
+ *   respaldo si el cliente no soporta HTML (default: "Contenido interactivo").
+ * @returns {{ message: object, messageId: string }}
+ */
+export const generateHtmlContent = (html, quoted, options = {}) => {
+  const {
+    trustedSources = [],
+    headerText,
+    footer,
+    fallbackText = "Contenido interactivo",
+  } = options;
+
+  const sections = [];
+
+  if (headerText) {
+    sections.push({
+      view_model: {
+        primitive: {
+          text: headerText,
+          __typename: "GenAIMarkdownTextUXPrimitive",
+        },
+        __typename: "GenAISingleLayoutViewModel",
+      },
+    });
+  }
+
+  sections.push({
+    view_model: {
+      primitive: {
+        __typename: "GenAIaeacdsnwHtmlPrimitive",
+        payload: html,
+        trusted_sources: trustedSources,
+      },
+      __typename: "GenAISingleLayoutViewModel",
+    },
+  });
+
+  if (footer) {
+    sections.push({
+      view_model: {
+        primitive: {
+          text: footer,
+          __typename: "GenAIMarkdownTextUXPrimitive",
+        },
+        __typename: "GenAISingleLayoutViewModel",
+      },
+    });
+  }
+
+  const responseId = randomUUID();
+  const unifiedData = {
+    response_id: responseId,
+    sections,
+    version: "1",
+    is_final: true,
+  };
+  const base64Data = Buffer.from(JSON.stringify(unifiedData)).toString(
+    "base64",
+  );
+
+  const submessages = [
+    {
+      messageType: 2, // AI_RICH_RESPONSE_TEXT
+      messageText: fallbackText,
+    },
+  ];
+
+  const ctxInfo = {
+    isForwarded: true,
+    forwardOrigin: 4, // META_AI
+  };
+  if (quoted?.key) {
+    ctxInfo.participant =
+      quoted.key.participant || quoted.sender || quoted.key.remoteJid;
+    ctxInfo.quotedMessage = quoted.message;
+  }
+
+  const content = {
+    messageContextInfo: {
+      threadId: [],
+      messageSecret: randomBytes(32),
+    },
+    botForwardedMessage: {
+      message: {
+        richResponseMessage: {
+          messageType: 1, // AI_RICH_RESPONSE_TYPE_STANDARD
+          submessages,
+          unifiedResponse: { data: base64Data },
+          contextInfo: ctxInfo,
+        },
+      },
+    },
+  };
+
+  return {
+    message: content,
+    messageId: generateMessageIDV2(),
+  };
+};
 //# sourceMappingURL=rich-messages.js.map

package/lib/Utils/scheduled-messages.d.ts

@@ -0,0 +1,122 @@
+import type { WASocket } from '../Socket/index.js';
+import type { AnyMessageContent } from '../Types/Message.js';
+
+export interface ScheduledMessage {
+    id: string;
+    jid: string;
+    content: AnyMessageContent;
+    type: 'once' | 'recurring';
+    timestamp?: number;
+    cron?: string;
+    sent?: boolean;
+    sentAt?: number;
+    cancelled?: boolean;
+    cancelledAt?: number;
+    createdAt: number;
+    lastSent?: number;
+    executionCount?: number;
+    lastError?: string;
+    errorCount?: number;
+    [key: string]: any;
+}
+
+export interface SchedulerStats {
+    total: number;
+    pending: number;
+    sent: number;
+    recurring: number;
+    cancelled: number;
+    errors: number;
+}
+
+export interface ScheduledMessageFilter {
+    jid?: string;
+    type?: 'once' | 'recurring';
+    cancelled?: boolean;
+    pending?: boolean;
+}
+
+/**
+ * Iniciar el scheduler de mensajes programados
+ * @param sock - Socket de conexión de WhatsApp
+ * @param intervalMs - Intervalo de revisión en ms (default: 30000)
+ */
+export declare const startScheduler: (sock: WASocket, intervalMs?: number) => void;
+
+/**
+ * Detener el scheduler
+ */
+export declare const stopScheduler: () => void;
+
+/**
+ * Programar un mensaje para enviar en una fecha/hora específica
+ * @param jid - Destinatario
+ * @param content - Contenido del mensaje
+ * @param timestamp - Fecha/hora de envío (timestamp ms o Date)
+ * @param options - Opciones adicionales (id personalizado, etc.)
+ * @returns ID del mensaje programado
+ */
+export declare const scheduleMessage: (
+    jid: string,
+    content: AnyMessageContent,
+    timestamp: number | Date,
+    options?: { id?: string; [key: string]: any }
+) => string;
+
+/**
+ * Programar un mensaje recurrente usando cron
+ * Formato: "MIN HOUR DOM MON DOW" (ej: "0 9 * * 1-5" = lunes a viernes a las 9am)
+ * @param jid - Destinatario
+ * @param content - Contenido del mensaje
+ * @param cron - Expresión cron
+ * @param options - Opciones adicionales
+ * @returns ID del mensaje programado
+ */
+export declare const recurringMessage: (
+    jid: string,
+    content: AnyMessageContent,
+    cron: string,
+    options?: { id?: string; [key: string]: any }
+) => string;
+
+/**
+ * Cancelar un mensaje programado
+ * @param id - ID del mensaje
+ * @returns true si se canceló
+ */
+export declare const cancelScheduledMessage: (id: string) => boolean;
+
+/**
+ * Eliminar un mensaje programado permanentemente
+ * @param id - ID del mensaje
+ * @returns true si se eliminó
+ */
+export declare const deleteScheduledMessage: (id: string) => boolean;
+
+/**
+ * Obtener todos los mensajes programados
+ * @param filter - Filtros opcionales
+ * @returns Lista de mensajes
+ */
+export declare const listScheduledMessages: (filter?: ScheduledMessageFilter) => ScheduledMessage[];
+
+/**
+ * Obtener un mensaje programado por ID
+ * @param id - ID del mensaje
+ * @returns Mensaje o null
+ */
+export declare const getScheduledMessage: (id: string) => ScheduledMessage | null;
+
+/**
+ * Actualizar el contenido de un mensaje programado
+ * @param id - ID del mensaje
+ * @param updates - Campos a actualizar
+ * @returns true si se actualizó
+ */
+export declare const updateScheduledMessage: (id: string, updates: Partial<ScheduledMessage>) => boolean;
+
+/**
+ * Obtener estadísticas del scheduler
+ * @returns Estadísticas
+ */
+export declare const getSchedulerStats: () => SchedulerStats;

package/lib/Utils/scheduled-messages.js

@@ -0,0 +1,289 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+const SCHEDULED_PATH = join(process.cwd(), 'database', 'scheduled-messages.json');
+const scheduled = new Map();
+let _sock = null;
+let _initialized = false;
+
+/**
+ * Parse a cron expression (simple format: "MIN HOUR DOM MON DOW")
+ * Returns true if the current time matches the cron
+ */
+function matchCron(cron, date) {
+    if (!cron || typeof cron !== 'string') return false;
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5) return false;
+
+    const [min, hour, dom, mon, dow] = parts;
+    const d = date || new Date();
+
+    const matchField = (field, value) => {
+        if (field === '*') return true;
+        if (field.includes(',')) return field.split(',').some(v => matchField(v.trim(), value));
+        if (field.includes('-')) {
+            const [start, end] = field.split('-').map(Number);
+            return value >= start && value <= end;
+        }
+        if (field.includes('/')) {
+            const [, step] = field.split('/');
+            return value % parseInt(step) === 0;
+        }
+        return parseInt(field) === value;
+    };
+
+    return (
+        matchField(min, d.getMinutes()) &&
+        matchField(hour, d.getHours()) &&
+        matchField(dom, d.getDate()) &&
+        matchField(mon, d.getMonth() + 1) &&
+        matchField(dow, d.getDay())
+    );
+}
+
+function loadScheduled() {
+    try {
+        if (existsSync(SCHEDULED_PATH)) {
+            const data = JSON.parse(readFileSync(SCHEDULED_PATH, 'utf8'));
+            if (Array.isArray(data)) {
+                for (const msg of data) {
+                    scheduled.set(msg.id, msg);
+                }
+            }
+        }
+    } catch { }
+}
+
+function saveScheduled() {
+    try {
+        const dirPath = join(process.cwd(), 'database');
+        if (!existsSync(dirPath)) mkdirSync(dirPath, { recursive: true });
+        const arr = Array.from(scheduled.values());
+        writeFileSync(SCHEDULED_PATH, JSON.stringify(arr, null, 2));
+    } catch { }
+}
+
+function generateId() {
+    return 'sch_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 8);
+}
+
+async function processScheduled() {
+    if (!_sock) return;
+    const now = Date.now();
+    let changed = false;
+
+    for (const [id, msg] of scheduled) {
+        if (msg.cancelled) continue;
+
+        const shouldSend =
+            (msg.type === 'once' && now >= msg.timestamp && !msg.sent) ||
+            (msg.type === 'recurring' && matchCron(msg.cron, new Date()));
+
+        if (shouldSend) {
+            try {
+                await _sock.sendMessage(msg.jid, msg.content);
+                changed = true;
+
+                if (msg.type === 'once') {
+                    msg.sent = true;
+                    msg.sentAt = now;
+                }
+
+                if (msg.type === 'recurring') {
+                    msg.lastSent = now;
+                    msg.executionCount = (msg.executionCount || 0) + 1;
+                }
+
+                _sock.logger?.info?.({ id, jid: msg.jid }, 'scheduled message sent');
+            } catch (err) {
+                _sock.logger?.warn?.({ err, id }, 'failed to send scheduled message');
+                msg.lastError = err.message;
+                msg.errorCount = (msg.errorCount || 0) + 1;
+            }
+        }
+
+        if (msg.type === 'once' && msg.sent) {
+            scheduled.delete(id);
+            changed = true;
+        }
+    }
+
+    if (changed) saveScheduled();
+}
+
+let _interval = null;
+
+function startScheduler(sock, intervalMs = 30000) {
+    _sock = sock;
+    if (!_initialized) {
+        loadScheduled();
+        _initialized = true;
+    }
+    if (_interval) clearInterval(_interval);
+    _interval = setInterval(processScheduled, intervalMs);
+    processScheduled();
+}
+
+function stopScheduler() {
+    if (_interval) {
+        clearInterval(_interval);
+        _interval = null;
+    }
+    _sock = null;
+}
+
+/**
+ * Programar un mensaje para enviar en una fecha/hora específica
+ * @param {string} jid - Destinatario
+ * @param {Object} content - Contenido del mensaje (igual que sendMessage)
+ * @param {number|Date} timestamp - Fecha/hora de envío (timestamp ms o Date)
+ * @param {Object} options - Opciones adicionales
+ * @returns {string} ID del mensaje programado
+ */
+function scheduleMessage(jid, content, timestamp, options = {}) {
+    const id = options.id || generateId();
+    const ts = timestamp instanceof Date ? timestamp.getTime() : timestamp;
+
+    const msg = {
+        id,
+        jid,
+        content,
+        timestamp: ts,
+        type: 'once',
+        sent: false,
+        createdAt: Date.now(),
+        ...options
+    };
+
+    scheduled.set(id, msg);
+    saveScheduled();
+    return id;
+}
+
+/**
+ * Programar un mensaje recurrente usando cron
+ * @param {string} jid - Destinatario
+ * @param {Object} content - Contenido del mensaje
+ * @param {string} cron - Expresión cron (MIN HOUR DOM MON DOW)
+ * @param {Object} options - Opciones adicionales
+ * @returns {string} ID del mensaje programado
+ */
+function recurringMessage(jid, content, cron, options = {}) {
+    const id = options.id || generateId();
+
+    const msg = {
+        id,
+        jid,
+        content,
+        cron,
+        type: 'recurring',
+        executionCount: 0,
+        createdAt: Date.now(),
+        ...options
+    };
+
+    scheduled.set(id, msg);
+    saveScheduled();
+    return id;
+}
+
+/**
+ * Cancelar un mensaje programado
+ * @param {string} id - ID del mensaje
+ * @returns {boolean} true si se canceló
+ */
+function cancelScheduledMessage(id) {
+    const msg = scheduled.get(id);
+    if (!msg) return false;
+    msg.cancelled = true;
+    msg.cancelledAt = Date.now();
+    saveScheduled();
+    return true;
+}
+
+/**
+ * Eliminar un mensaje programado permanentemente
+ * @param {string} id - ID del mensaje
+ * @returns {boolean} true si se eliminó
+ */
+function deleteScheduledMessage(id) {
+    const deleted = scheduled.delete(id);
+    if (deleted) saveScheduled();
+    return deleted;
+}
+
+/**
+ * Obtener todos los mensajes programados
+ * @param {Object} filter - Filtros opcionales
+ * @returns {Object[]} Lista de mensajes
+ */
+function listScheduledMessages(filter = {}) {
+    let msgs = Array.from(scheduled.values());
+
+    if (filter.jid) {
+        msgs = msgs.filter(m => m.jid === filter.jid);
+    }
+    if (filter.type) {
+        msgs = msgs.filter(m => m.type === filter.type);
+    }
+    if (filter.cancelled === false) {
+        msgs = msgs.filter(m => !m.cancelled);
+    }
+    if (filter.pending) {
+        msgs = msgs.filter(m => m.type === 'once' && !m.sent && !m.cancelled);
+    }
+
+    return msgs.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+}
+
+/**
+ * Obtener un mensaje programado por ID
+ * @param {string} id - ID del mensaje
+ * @returns {Object|null}
+ */
+function getScheduledMessage(id) {
+    return scheduled.get(id) || null;
+}
+
+/**
+ * Actualizar el contenido de un mensaje programado
+ * @param {string} id - ID del mensaje
+ * @param {Object} updates - Campos a actualizar
+ * @returns {boolean}
+ */
+function updateScheduledMessage(id, updates) {
+    const msg = scheduled.get(id);
+    if (!msg) return false;
+    Object.assign(msg, updates);
+    saveScheduled();
+    return true;
+}
+
+/**
+ * Obtener estadísticas del scheduler
+ * @returns {Object}
+ */
+function getSchedulerStats() {
+    const msgs = Array.from(scheduled.values());
+    return {
+        total: msgs.length,
+        pending: msgs.filter(m => m.type === 'once' && !m.sent && !m.cancelled).length,
+        sent: msgs.filter(m => m.type === 'once' && m.sent).length,
+        recurring: msgs.filter(m => m.type === 'recurring' && !m.cancelled).length,
+        cancelled: msgs.filter(m => m.cancelled).length,
+        errors: msgs.filter(m => m.lastError).length
+    };
+}
+
+export {
+    startScheduler,
+    stopScheduler,
+    scheduleMessage,
+    recurringMessage,
+    cancelScheduledMessage,
+    deleteScheduledMessage,
+    listScheduledMessages,
+    getScheduledMessage,
+    updateScheduledMessage,
+    getSchedulerStats
+};

package/lib/Utils/smart-reconnect.d.ts

@@ -0,0 +1,48 @@
+export declare const RECONNECT_CONFIG: {
+    MAX_RETRIES: number;
+    INITIAL_DELAY: number;
+    MAX_DELAY: number;
+    BACKOFF_FACTOR: number;
+    JITTER_FACTOR: number;
+    STABLE_CONNECTION_TIME: number;
+    RECOVERABLE_REASONS: number[];
+    FATAL_REASONS: number[];
+};
+
+export declare class SmartReconnect {
+    constructor(logger?: any, config?: Partial<typeof RECONNECT_CONFIG>);
+    retryCount: number;
+    connectionStable: boolean;
+    calculateDelay(): number;
+    shouldReconnect(reason: string, statusCode?: number): { shouldReconnect: boolean; reason?: string; delay?: number };
+    handleDisconnect(reason: string, statusCode: number | undefined, reconnectCallback: () => Promise<void>): Promise<{ reconnecting: boolean; reason?: string; success?: boolean; error?: any }>;
+    onSuccessfulReconnect(): void;
+    cancelPendingReconnect(): void;
+    reset(): void;
+    getStats(): {
+        totalReconnects: number;
+        successfulReconnects: number;
+        failedReconnects: number;
+        lastSuccessfulConnect: string | null;
+        averageDowntime: number;
+        currentRetryCount: number;
+        isStable: boolean;
+        lastDisconnect: { reason: string; statusCode?: number; time: number } | null;
+    };
+    startHealthCheck(pingCallback: () => Promise<void>, interval?: number): void;
+    stopHealthCheck(): void;
+    cleanup(): void;
+}
+
+export declare function createConnectionHandler(sock: any, logger?: any, options?: Partial<typeof RECONNECT_CONFIG>): {
+    reconnect: SmartReconnect;
+    handleConnectionUpdate(update: any, startSock: () => Promise<void>): Promise<any>;
+    getStatus(): { stats: ReturnType<SmartReconnect['getStats']>; isHealthy: boolean };
+};
+
+export declare function withRetry<T>(fn: () => Promise<T>, options?: {
+    maxRetries?: number;
+    delay?: number;
+    backoff?: number;
+    onRetry?: ((error: any, attempt: number, waitTime: number) => void) | null;
+}): Promise<T>;