@omnizap-system/omnizap 2.5.12

package/app/configParts/loggerConfig.js

@@ -0,0 +1,394 @@
+import pino from 'pino';
+import { criarInstanciaLogger } from '@kaikybrofc/logger-module';
+import baseLogger from '#logger';
+
+const DEFAULT_BAILEYS_LABEL = 'baileys';
+const DEFAULT_BAILEYS_LOGGER_MODE = 'child';
+const BAILEYS_LOGGER_MODES = new Set(['child', 'instance']);
+const DEFAULT_BAILEYS_SOCKET_LOGGER_MODE = 'silent';
+const BAILEYS_SOCKET_LOGGER_MODES = new Set(['silent', 'pino', 'bridge']);
+const DEFAULT_PINO_LEVEL = 'info';
+const DEFAULT_PINO_SILENT_LEVEL = 'silent';
+const PINO_LEVELS = new Set(['trace', 'debug', 'info', 'warn', 'error', 'fatal', 'silent']);
+const PINO_LEVEL_PRIORITY = Object.freeze({
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60,
+  silent: Number.POSITIVE_INFINITY,
+});
+const BAILEYS_TO_WINSTON_LEVEL = Object.freeze({
+  trace: 'debug',
+  debug: 'debug',
+  info: 'info',
+  warn: 'warn',
+  error: 'error',
+});
+const BAILEYS_LOG_METHOD_PRIORITY = Object.freeze({
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+});
+
+const parseEnvBool = (value, fallback) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+};
+
+const parseJsonObject = (value, fallback = {}, context = 'JSON') => {
+  if (value === undefined || value === null || String(value).trim() === '') {
+    return { ...fallback };
+  }
+
+  try {
+    const parsed = JSON.parse(String(value));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return { ...fallback };
+  } catch (error) {
+    baseLogger.warn(`Valor inválido em ${context}. Usando fallback.`, {
+      errorMessage: error?.message,
+    });
+    return { ...fallback };
+  }
+};
+
+const parseTransportDefinitions = (value) => {
+  if (value === undefined || value === null || String(value).trim() === '') {
+    return undefined;
+  }
+
+  try {
+    const parsed = JSON.parse(String(value));
+    if (!Array.isArray(parsed)) return undefined;
+
+    const validDefinitions = parsed.filter((entry) => entry && typeof entry === 'object' && typeof entry.type === 'string' && entry.options && typeof entry.options === 'object');
+    return validDefinitions.length > 0 ? validDefinitions : undefined;
+  } catch (error) {
+    baseLogger.warn('Valor inválido em BAILEYS_LOGGER_TRANSPORT_DEFINITIONS_JSON. Ignorando customização de transportes.', {
+      errorMessage: error?.message,
+    });
+    return undefined;
+  }
+};
+
+const normalizeLoggerMode = (value, fallback = DEFAULT_BAILEYS_LOGGER_MODE) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  return BAILEYS_LOGGER_MODES.has(normalized) ? normalized : fallback;
+};
+
+const normalizeSocketLoggerMode = (value, fallback = DEFAULT_BAILEYS_SOCKET_LOGGER_MODE) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  return BAILEYS_SOCKET_LOGGER_MODES.has(normalized) ? normalized : fallback;
+};
+
+const normalizeLabel = (value, fallback = DEFAULT_BAILEYS_LABEL) => {
+  const normalized = String(value || '')
+    .trim()
+    .replace(/\s+/g, '_');
+  return normalized || fallback;
+};
+
+const normalizePinoLevel = (value, fallback = DEFAULT_PINO_LEVEL) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  return PINO_LEVELS.has(normalized) ? normalized : fallback;
+};
+
+const mapWinstonLevelToPinoLevel = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+
+  if (['fatal', 'emerg', 'alert', 'crit'].includes(normalized)) return 'fatal';
+  if (normalized === 'error') return 'error';
+  if (['warn', 'notice'].includes(normalized)) return 'warn';
+  if (['info', 'success', 'http'].includes(normalized)) return 'info';
+  if (['debug', 'verbose'].includes(normalized)) return 'debug';
+  if (normalized === 'silly') return 'trace';
+
+  return DEFAULT_PINO_LEVEL;
+};
+
+const shouldEmitByPinoLevel = (level, method) => {
+  const normalizedLevel = normalizePinoLevel(level, DEFAULT_PINO_LEVEL);
+  const threshold = PINO_LEVEL_PRIORITY[normalizedLevel] ?? PINO_LEVEL_PRIORITY[DEFAULT_PINO_LEVEL];
+  const methodPriority = BAILEYS_LOG_METHOD_PRIORITY[method] ?? BAILEYS_LOG_METHOD_PRIORITY.info;
+  return methodPriority >= threshold;
+};
+
+const resolveBaseServiceName = () => {
+  const raw = String(process.env.name || process.env.ECOSYSTEM_NAME || '').trim();
+  return raw || 'sistema';
+};
+
+const createLoggerChild = (logger, defaultMeta) => {
+  if (logger && typeof logger.child === 'function') {
+    return logger.child(defaultMeta);
+  }
+  return logger || baseLogger;
+};
+
+const resolveBaileysLoggerConfig = (overrides = {}) => {
+  const mode = normalizeLoggerMode(overrides.mode ?? process.env.BAILEYS_LOGGER_MODE, DEFAULT_BAILEYS_LOGGER_MODE);
+  const level = String(overrides.level ?? process.env.BAILEYS_LOGGER_LEVEL ?? '').trim() || undefined;
+  const label = normalizeLabel(overrides.label ?? process.env.BAILEYS_LOGGER_LABEL, DEFAULT_BAILEYS_LABEL);
+  const service = String(overrides.service ?? process.env.BAILEYS_LOGGER_SERVICE ?? '').trim() || `${resolveBaseServiceName()}-baileys`;
+  const enableCustomMeta = parseEnvBool(process.env.BAILEYS_LOGGER_ENABLE_META_JSON, true);
+  const envMeta = enableCustomMeta ? parseJsonObject(process.env.BAILEYS_LOGGER_META_JSON, {}, 'BAILEYS_LOGGER_META_JSON') : {};
+  const overrideMeta = overrides.defaultMeta && typeof overrides.defaultMeta === 'object' ? overrides.defaultMeta : {};
+  const defaultMeta = {
+    ...envMeta,
+    ...overrideMeta,
+    label,
+    service,
+  };
+
+  const transportDefinitions = overrides.transportDefinitions || parseTransportDefinitions(process.env.BAILEYS_LOGGER_TRANSPORT_DEFINITIONS_JSON);
+  const transports = Array.isArray(overrides.transports) ? overrides.transports : undefined;
+  const format = overrides.format;
+
+  return {
+    mode,
+    level,
+    label,
+    service,
+    defaultMeta,
+    transportDefinitions,
+    transports,
+    format,
+  };
+};
+
+const resolveBaileysSocketLoggerConfig = (overrides = {}) => {
+  const mode = normalizeSocketLoggerMode(overrides.mode ?? process.env.BAILEYS_SOCKET_LOGGER_MODE, DEFAULT_BAILEYS_SOCKET_LOGGER_MODE);
+  const fallbackLevel = mode === 'silent' ? DEFAULT_PINO_SILENT_LEVEL : DEFAULT_PINO_LEVEL;
+  const level = normalizePinoLevel(overrides.level ?? process.env.BAILEYS_SOCKET_LOGGER_LEVEL, fallbackLevel);
+  const enableCustomMeta = parseEnvBool(process.env.BAILEYS_SOCKET_LOGGER_ENABLE_META_JSON, true);
+  const envBase = enableCustomMeta ? parseJsonObject(process.env.BAILEYS_SOCKET_LOGGER_META_JSON, {}, 'BAILEYS_SOCKET_LOGGER_META_JSON') : {};
+  const overrideBase = overrides.base && typeof overrides.base === 'object' ? overrides.base : {};
+  const base = {
+    ...envBase,
+    ...overrideBase,
+  };
+  const envOptions = parseJsonObject(process.env.BAILEYS_SOCKET_LOGGER_OPTIONS_JSON, {}, 'BAILEYS_SOCKET_LOGGER_OPTIONS_JSON');
+  const overrideOptions = overrides.options && typeof overrides.options === 'object' ? overrides.options : {};
+  const options = {
+    ...envOptions,
+    ...overrideOptions,
+  };
+
+  return {
+    mode,
+    level,
+    base,
+    options,
+  };
+};
+
+const createConfiguredBaileysLogger = (overrides = {}) => {
+  const config = resolveBaileysLoggerConfig(overrides);
+
+  if (config.mode === 'instance') {
+    return criarInstanciaLogger({
+      level: config.level,
+      defaultMeta: config.defaultMeta,
+      transportDefinitions: config.transportDefinitions,
+      transports: config.transports,
+      format: config.format,
+    });
+  }
+
+  const childLogger = createLoggerChild(baseLogger, config.defaultMeta);
+  if (config.level && typeof childLogger === 'object' && childLogger) {
+    childLogger.level = config.level;
+  }
+  return childLogger;
+};
+
+const serializeError = (error) => ({
+  errorName: error?.name || 'Error',
+  errorMessage: error?.message || String(error),
+  errorStack: error?.stack,
+});
+
+const resolveLogEntry = (obj, msg) => {
+  const providedMessage = typeof msg === 'string' ? msg.trim() : '';
+  let message = providedMessage;
+  let metadata;
+
+  if (obj instanceof Error) {
+    metadata = serializeError(obj);
+    if (!message) message = obj.message || 'erro_em_logger_baileys';
+  } else if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+    metadata = { ...obj };
+    if (!message && typeof obj.msg === 'string') {
+      message = obj.msg.trim();
+    }
+    if (!message && typeof obj.message === 'string') {
+      message = obj.message.trim();
+    }
+  } else if (obj !== undefined && obj !== null) {
+    if (!message && typeof obj === 'string') {
+      message = obj.trim();
+    } else {
+      metadata = { value: obj };
+    }
+  }
+
+  if (!message) {
+    message = 'baileys_socket_event';
+  }
+
+  return {
+    message,
+    metadata: metadata && Object.keys(metadata).length > 0 ? metadata : undefined,
+  };
+};
+
+const writeBridgeLog = (targetLogger, method, obj, msg) => {
+  const methodName = BAILEYS_TO_WINSTON_LEVEL[method] || 'info';
+  const { message, metadata } = resolveLogEntry(obj, msg);
+  const targetMethod = typeof targetLogger?.[methodName] === 'function' ? targetLogger[methodName].bind(targetLogger) : null;
+
+  if (targetMethod) {
+    if (metadata) {
+      targetMethod(message, metadata);
+    } else {
+      targetMethod(message);
+    }
+    return;
+  }
+
+  if (typeof targetLogger?.log === 'function') {
+    if (metadata) {
+      targetLogger.log(methodName, message, metadata);
+    } else {
+      targetLogger.log(methodName, message);
+    }
+  }
+};
+
+const createBaileysSocketBridgeLogger = (rootLogger, level) => {
+  const sharedState = {
+    level: normalizePinoLevel(level, mapWinstonLevelToPinoLevel(rootLogger?.level)),
+  };
+
+  const createAdapter = (targetLogger) => ({
+    get level() {
+      return sharedState.level;
+    },
+    set level(nextLevel) {
+      sharedState.level = normalizePinoLevel(nextLevel, sharedState.level);
+    },
+    child(bindings = {}) {
+      const normalizedBindings = bindings && typeof bindings === 'object' ? bindings : {};
+      const childLogger = createLoggerChild(targetLogger, normalizedBindings);
+      return createAdapter(childLogger);
+    },
+    trace(obj, msg) {
+      if (!shouldEmitByPinoLevel(sharedState.level, 'trace')) return;
+      writeBridgeLog(targetLogger, 'trace', obj, msg);
+    },
+    debug(obj, msg) {
+      if (!shouldEmitByPinoLevel(sharedState.level, 'debug')) return;
+      writeBridgeLog(targetLogger, 'debug', obj, msg);
+    },
+    info(obj, msg) {
+      if (!shouldEmitByPinoLevel(sharedState.level, 'info')) return;
+      writeBridgeLog(targetLogger, 'info', obj, msg);
+    },
+    warn(obj, msg) {
+      if (!shouldEmitByPinoLevel(sharedState.level, 'warn')) return;
+      writeBridgeLog(targetLogger, 'warn', obj, msg);
+    },
+    error(obj, msg) {
+      if (!shouldEmitByPinoLevel(sharedState.level, 'error')) return;
+      writeBridgeLog(targetLogger, 'error', obj, msg);
+    },
+  });
+
+  return createAdapter(rootLogger || baseLogger);
+};
+
+let cachedBaileysRootLogger = null;
+let cachedBaileysSocketLogger = null;
+
+const getDefaultBaileysRootLogger = () => {
+  if (!cachedBaileysRootLogger) {
+    cachedBaileysRootLogger = createConfiguredBaileysLogger();
+  }
+  return cachedBaileysRootLogger;
+};
+
+const createConfiguredBaileysSocketLogger = (overrides = {}) => {
+  const config = resolveBaileysSocketLoggerConfig(overrides);
+  const mergedBase = {
+    ...(config.options?.base && typeof config.options.base === 'object' ? config.options.base : {}),
+    ...config.base,
+  };
+
+  if (config.mode === 'bridge') {
+    const bridgeLogger = createBaileysScopedLogger('socket', mergedBase);
+    return createBaileysSocketBridgeLogger(bridgeLogger, config.level);
+  }
+
+  const level = config.mode === 'silent' ? DEFAULT_PINO_SILENT_LEVEL : config.level;
+  const pinoOptions = {
+    ...config.options,
+    level,
+  };
+  if (Object.keys(mergedBase).length > 0) {
+    pinoOptions.base = mergedBase;
+  }
+  return pino(pinoOptions);
+};
+
+export const createBaileysLogger = (overrides = {}) => {
+  if (!overrides || Object.keys(overrides).length === 0) {
+    return getDefaultBaileysRootLogger();
+  }
+  return createConfiguredBaileysLogger(overrides);
+};
+
+export const createBaileysScopedLogger = (scope, metadata = {}) => {
+  const rootLogger = getDefaultBaileysRootLogger();
+  const rootLabel = resolveBaileysLoggerConfig().label;
+  const normalizedScope = normalizeLabel(scope, '');
+  const scopedLabel = normalizedScope ? `${rootLabel}.${normalizedScope}` : rootLabel;
+  const scopedMeta = {
+    ...metadata,
+    label: scopedLabel,
+  };
+  return createLoggerChild(rootLogger, scopedMeta);
+};
+
+export const createBaileysSocketLogger = (overrides = {}) => {
+  if (!overrides || Object.keys(overrides).length === 0) {
+    if (!cachedBaileysSocketLogger) {
+      cachedBaileysSocketLogger = createConfiguredBaileysSocketLogger();
+    }
+    return cachedBaileysSocketLogger;
+  }
+  return createConfiguredBaileysSocketLogger(overrides);
+};
+
+export const baileysLogger = createBaileysScopedLogger('');
+export const baileysConnectionLogger = createBaileysScopedLogger('connection');
+export const baileysConfigLogger = createBaileysScopedLogger('config');
+export const baileysAuthLogger = createBaileysScopedLogger('auth');
+export const baileysGroupsLogger = createBaileysScopedLogger('groups');
+export const baileysSocketLogger = createBaileysSocketLogger();

package/app/configParts/messagePersistenceService.js

@@ -0,0 +1,305 @@
+import { baileysConnectionLogger as logger } from './loggerConfig.js';
+import { queueMessageInsert } from '../services/infra/dbWriteQueue.js';
+import { parseEnvBool, parseEnvInt, normalizeJid, isGroupJid, isStatusJid, isBroadcastJid, isNewsletterJid, normalizeWAPresence } from './baileysConfig.js';
+
+const BAILEYS_SEND_RETRY_ATTEMPTS = parseEnvInt(process.env.BAILEYS_SEND_RETRY_ATTEMPTS, 2, 1, 5);
+const BAILEYS_SEND_RETRY_BASE_DELAY_MS = parseEnvInt(process.env.BAILEYS_SEND_RETRY_BASE_DELAY_MS, 600, 100, 10_000);
+const BAILEYS_SEND_MEDIA_UPLOAD_TIMEOUT_MS = parseEnvInt(process.env.BAILEYS_SEND_MEDIA_UPLOAD_TIMEOUT_MS, 0, 0, 120_000);
+const BAILEYS_REPLY_PRESENCE_ENABLED = parseEnvBool(process.env.BAILEYS_REPLY_PRESENCE_ENABLED, true);
+const BAILEYS_REPLY_PRESENCE_SUBSCRIBE = parseEnvBool(process.env.BAILEYS_REPLY_PRESENCE_SUBSCRIBE, true);
+const BAILEYS_REPLY_PRESENCE_DELAY_MS = parseEnvInt(process.env.BAILEYS_REPLY_PRESENCE_DELAY_MS, 280, 0, 3_000);
+const BAILEYS_REPLY_PRESENCE_BEFORE = normalizeWAPresence(process.env.BAILEYS_REPLY_PRESENCE_BEFORE, 'composing');
+const BAILEYS_REPLY_PRESENCE_AFTER = normalizeWAPresence(process.env.BAILEYS_REPLY_PRESENCE_AFTER, 'paused');
+
+const isPlainObject = (value) => Object.prototype.toString.call(value) === '[object Object]';
+
+const ANY_MESSAGE_CONTENT_PRIMARY_KEYS = new Set(['text', 'image', 'video', 'audio', 'sticker', 'stickerPack', 'stickerPackMessage', 'document', 'event', 'poll', 'contacts', 'location', 'react', 'buttonReply', 'groupInvite', 'listReply', 'pin', 'product', 'sharePhoneNumber', 'requestPhoneNumber', 'forward', 'delete', 'disappearingMessagesInChat', 'limitSharing']);
+const PRESENCE_NON_REPLY_CONTENT_KEYS = new Set(['react', 'delete', 'pin', 'disappearingMessagesInChat']);
+
+/**
+ * Verifica se o payload se parece com AnyMessageContent do Baileys.
+ * @param {unknown} content
+ * @returns {boolean}
+ */
+const hasKnownAnyMessageContentShape = (content) => {
+  if (!isPlainObject(content)) return false;
+  return Object.keys(content).some((key) => ANY_MESSAGE_CONTENT_PRIMARY_KEYS.has(key));
+};
+
+/**
+ * Normaliza opções de envio aceitas pelo Baileys (MiscMessageGenerationOptions).
+ * @param {unknown} options
+ * @returns {import('@whiskeysockets/baileys').MiscMessageGenerationOptions|undefined}
+ */
+const normalizeSendOptions = (options) => {
+  if (!isPlainObject(options)) return undefined;
+
+  const normalized = { ...options };
+
+  if (typeof normalized.messageId === 'string') {
+    const trimmedMessageId = normalized.messageId.trim();
+    if (trimmedMessageId) {
+      normalized.messageId = trimmedMessageId;
+    } else {
+      delete normalized.messageId;
+    }
+  }
+
+  if (typeof normalized.mediaUploadTimeoutMs !== 'number' && BAILEYS_SEND_MEDIA_UPLOAD_TIMEOUT_MS > 0) {
+    normalized.mediaUploadTimeoutMs = BAILEYS_SEND_MEDIA_UPLOAD_TIMEOUT_MS;
+  }
+
+  if (normalized.statusJidList !== undefined && !Array.isArray(normalized.statusJidList)) {
+    delete normalized.statusJidList;
+  }
+
+  return normalized;
+};
+
+/**
+ * Separa opções internas de presença das opções reais de envio do Baileys.
+ * @param {unknown} options
+ * @returns {{
+ *   sendOptions: import('@whiskeysockets/baileys').MiscMessageGenerationOptions|undefined,
+ *   skipPresenceUpdate: boolean,
+ *   presenceBefore: import('@whiskeysockets/baileys').WAPresence,
+ *   presenceAfter: import('@whiskeysockets/baileys').WAPresence,
+ *   presenceDelayMs: number,
+ *   presenceSubscribe: boolean
+ * }}
+ */
+const resolveRuntimeSendOptions = (options) => {
+  if (!isPlainObject(options)) {
+    return {
+      sendOptions: undefined,
+      skipPresenceUpdate: false,
+      presenceBefore: BAILEYS_REPLY_PRESENCE_BEFORE,
+      presenceAfter: BAILEYS_REPLY_PRESENCE_AFTER,
+      presenceDelayMs: BAILEYS_REPLY_PRESENCE_DELAY_MS,
+      presenceSubscribe: BAILEYS_REPLY_PRESENCE_SUBSCRIBE,
+    };
+  }
+
+  const { skipPresenceUpdate, presenceBefore, presenceAfter, presenceDelayMs, presenceSubscribe, ...sendOptions } = options;
+  const normalizedDelay = parseEnvInt(presenceDelayMs, BAILEYS_REPLY_PRESENCE_DELAY_MS, 0, 3_000);
+  return {
+    sendOptions: Object.keys(sendOptions).length > 0 ? sendOptions : undefined,
+    skipPresenceUpdate: Boolean(skipPresenceUpdate),
+    presenceBefore: normalizeWAPresence(presenceBefore, BAILEYS_REPLY_PRESENCE_BEFORE),
+    presenceAfter: normalizeWAPresence(presenceAfter, BAILEYS_REPLY_PRESENCE_AFTER),
+    presenceDelayMs: normalizedDelay,
+    presenceSubscribe: typeof presenceSubscribe === 'boolean' ? presenceSubscribe : BAILEYS_REPLY_PRESENCE_SUBSCRIBE,
+  };
+};
+
+/**
+ * Indica se o conteúdo é uma resposta "normal" (texto/mídia) que merece presença.
+ * @param {unknown} content
+ * @returns {boolean}
+ */
+const shouldApplyPresenceByContent = (content) => {
+  if (!isPlainObject(content)) return false;
+  const keys = Object.keys(content);
+  if (keys.length === 0) return false;
+  return !keys.every((key) => PRESENCE_NON_REPLY_CONTENT_KEYS.has(key));
+};
+
+/**
+ * Resolve se a presença deve ser enviada para este envio.
+ * @param {string} jid
+ * @param {unknown} content
+ * @param {{skipPresenceUpdate: boolean}} runtimeOptions
+ * @returns {boolean}
+ */
+const shouldSendReplyPresence = (jid, content, runtimeOptions) => {
+  if (!BAILEYS_REPLY_PRESENCE_ENABLED) return false;
+  if (runtimeOptions.skipPresenceUpdate) return false;
+  if (!shouldApplyPresenceByContent(content)) return false;
+
+  const normalizedJid = normalizeJid(jid) || String(jid || '').trim();
+  if (!normalizedJid) return false;
+  if (isGroupJid(normalizedJid)) return false;
+  if (isStatusJid(normalizedJid)) return false;
+  if (isBroadcastJid(normalizedJid)) return false;
+  if (isNewsletterJid(normalizedJid)) return false;
+
+  return true;
+};
+
+const sendPresenceSilently = async (sock, type, jid, subscribeFirst = false) => {
+  if (!sock || typeof sock.sendPresenceUpdate !== 'function') return;
+  try {
+    if (subscribeFirst && typeof sock.presenceSubscribe === 'function') {
+      await sock.presenceSubscribe(jid);
+    }
+    await sock.sendPresenceUpdate(type, jid);
+  } catch (error) {
+    logger.debug('Falha ao enviar atualização de presença no Baileys.', {
+      jid,
+      presence: type,
+      error: error?.message,
+    });
+  }
+};
+
+/**
+ * Converte um timestamp da mensagem para ms com fallback seguro.
+ * @param {import('@whiskeysockets/baileys').WAMessage} msg
+ * @returns {number}
+ */
+const resolveMessageTimestampMs = (msg) => {
+  const rawTimestamp = msg?.messageTimestamp;
+  if (rawTimestamp !== null && rawTimestamp !== undefined) {
+    const tsNumber = typeof rawTimestamp === 'number' ? rawTimestamp : Number(rawTimestamp);
+    if (Number.isFinite(tsNumber) && tsNumber > 0) {
+      return tsNumber * 1000;
+    }
+  }
+  return Date.now();
+};
+
+/**
+ * Normaliza uma mensagem do Baileys para o formato persistido no banco.
+ * @param {import('@whiskeysockets/baileys').WAMessage} msg - Mensagem recebida/enviada.
+ * @param {string} [senderId] - ID do remetente (opcional).
+ * @returns {Object} Objeto com dados prontos para persistencia.
+ */
+export const buildMessageData = (msg, senderId) => ({
+  message_id: msg?.key?.id,
+  chat_id: msg?.key?.remoteJid,
+  sender_id: senderId || msg?.key?.participant || msg?.key?.remoteJid,
+  content: msg?.message?.conversation || msg?.message?.extendedTextMessage?.text || null,
+  raw_message: msg || {},
+  timestamp: new Date(resolveMessageTimestampMs(msg)),
+});
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, Number(ms) || 0)));
+
+const isTransientSendError = (error) => {
+  const statusCode = Number(error?.output?.statusCode || error?.statusCode || 0);
+  if ([408, 409, 425, 429, 500, 502, 503, 504].includes(statusCode)) return true;
+
+  const code = String(error?.code || '')
+    .trim()
+    .toUpperCase();
+  if (['ETIMEDOUT', 'ECONNRESET', 'ECONNABORTED', 'EAI_AGAIN', 'ENOTFOUND', 'ERR_SOCKET_CLOSED', 'ERR_NETWORK'].includes(code)) {
+    return true;
+  }
+
+  const rawMessage = `${error?.message || ''} ${error?.data?.message || ''}`.toLowerCase();
+  const transientFragments = ['timeout', 'timed out', 'connection closed', 'socket closed', 'media conn', 'media_conn', 'fetch failed', 'temporarily unavailable', 'network'];
+  return transientFragments.some((fragment) => rawMessage.includes(fragment));
+};
+
+const shouldRefreshMediaConnection = (error) => {
+  const rawMessage = `${error?.message || ''} ${error?.data?.message || ''}`.toLowerCase();
+  return rawMessage.includes('media') || rawMessage.includes('directpath') || rawMessage.includes('upload');
+};
+
+/**
+ * Envia uma mensagem via Baileys e persiste imediatamente o retorno.
+ * @param {import('@whiskeysockets/baileys').WASocket} sock
+ * @param {string} jid
+ * @param {import('@whiskeysockets/baileys').AnyMessageContent} content
+ * @param {import('@whiskeysockets/baileys').MiscMessageGenerationOptions & {
+ *   skipPresenceUpdate?: boolean,
+ *   presenceBefore?: import('@whiskeysockets/baileys').WAPresence,
+ *   presenceAfter?: import('@whiskeysockets/baileys').WAPresence,
+ *   presenceDelayMs?: number,
+ *   presenceSubscribe?: boolean
+ * }} [options]
+ * @returns {Promise<import('@whiskeysockets/baileys').WAMessage|undefined>}
+ */
+export async function sendAndStore(sock, jid, content, options) {
+  if (!sock || typeof sock.sendMessage !== 'function') {
+    throw new TypeError('Socket Baileys inválido: sendMessage indisponível.');
+  }
+
+  if (!jid || typeof jid !== 'string') {
+    throw new TypeError('JID inválido para envio de mensagem.');
+  }
+
+  if (!hasKnownAnyMessageContentShape(content)) {
+    const payloadKeys = isPlainObject(content) ? Object.keys(content).slice(0, 10) : [];
+    throw new TypeError(`Payload de mensagem inválido. Chaves recebidas: ${payloadKeys.join(', ') || 'nenhuma'}`);
+  }
+
+  const normalizedJid = normalizeJid(jid) || String(jid).trim();
+  const runtimeOptions = resolveRuntimeSendOptions(options);
+  const normalizedOptions = normalizeSendOptions(runtimeOptions.sendOptions);
+  const shouldSendPresence = shouldSendReplyPresence(normalizedJid, content, runtimeOptions);
+
+  if (shouldSendPresence) {
+    await sendPresenceSilently(sock, runtimeOptions.presenceBefore, normalizedJid, runtimeOptions.presenceSubscribe);
+    if (runtimeOptions.presenceDelayMs > 0) {
+      await wait(runtimeOptions.presenceDelayMs);
+    }
+  }
+
+  let attempt = 0;
+  let sent;
+  let lastError;
+
+  try {
+    while (attempt < BAILEYS_SEND_RETRY_ATTEMPTS) {
+      attempt += 1;
+      try {
+        sent = await sock.sendMessage(normalizedJid, content, normalizedOptions);
+        break;
+      } catch (error) {
+        lastError = error;
+        const shouldRetry = attempt < BAILEYS_SEND_RETRY_ATTEMPTS && isTransientSendError(error);
+        if (!shouldRetry) {
+          throw error;
+        }
+
+        if (shouldRefreshMediaConnection(error) && typeof sock?.refreshMediaConn === 'function') {
+          try {
+            await sock.refreshMediaConn(true);
+          } catch (refreshError) {
+            logger.debug('Falha ao forçar refresh de mediaConn antes do retry.', {
+              error: refreshError?.message,
+              attempt,
+              jid: normalizedJid,
+            });
+          }
+        }
+
+        const delayMs = BAILEYS_SEND_RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1);
+        logger.warn('Falha transitória ao enviar mensagem; novo retry agendado.', {
+          attempt,
+          maxAttempts: BAILEYS_SEND_RETRY_ATTEMPTS,
+          delayMs,
+          jid: normalizedJid,
+          code: error?.code || null,
+          statusCode: error?.output?.statusCode || error?.statusCode || null,
+          error: error?.message,
+        });
+        await wait(delayMs);
+      }
+    }
+  } finally {
+    if (shouldSendPresence) {
+      await sendPresenceSilently(sock, runtimeOptions.presenceAfter, normalizedJid, false);
+    }
+  }
+
+  if (!sent) {
+    throw lastError || new Error('Falha ao enviar mensagem: resultado vazio.');
+  }
+
+  const senderId = sock?.user?.id || sent?.key?.participant;
+  if (sent?.key?.id) {
+    try {
+      queueMessageInsert(buildMessageData(sent, senderId));
+    } catch (error) {
+      logger.warn('Falha ao enfileirar mensagem enviada para persistencia.', {
+        error: error.message,
+        messageId: sent?.key?.id,
+        remoteJid: sent?.key?.remoteJid,
+      });
+    }
+  }
+
+  return sent;
+}