@omnizap-system/omnizap 2.5.12

package/app/services/messaging/newsBroadcastService.js

@@ -0,0 +1,347 @@
+import axios from 'axios';
+import logger from '#logger';
+import groupConfigStore from '../../store/groupConfigStore.js';
+import { TABLES, findAll } from '../../../database/index.js';
+import { getActiveSocket } from '../../config/index.js';
+import getImageBuffer from '../../utils/http/getImageBufferModule.js';
+import { sendAndStore } from './messagePersistenceService.js';
+
+const DEFAULT_NEWS_API_URL = 'http://127.0.0.1:3001';
+const NEWS_API_URL = (process.env.NEWS_API_URL || DEFAULT_NEWS_API_URL).replace(/\/+$/, '');
+const MIN_DELAY_MS = 60 * 1000;
+const MAX_DELAY_MS = 120 * 1000;
+const MAX_SENT_IDS = Number(process.env.NEWS_SENT_IDS_LIMIT || 500);
+const LOOP_START_DELAY_MS = 5000;
+const GROUP_UNAVAILABLE_ERROR_PATTERNS = ['item-not-found', 'not-authorized', 'not in group', 'group does not exist', 'recipient not found', 'recipient-unavailable'];
+
+const groupLoops = new Map();
+
+const getRandomDelayMs = () => {
+  const min = MIN_DELAY_MS;
+  const max = MAX_DELAY_MS;
+  return Math.floor(min + Math.random() * (max - min + 1));
+};
+
+const parseConfigValue = (value) => {
+  if (value === null || value === undefined) return {};
+  if (Buffer.isBuffer(value)) {
+    try {
+      return JSON.parse(value.toString('utf8'));
+    } catch (error) {
+      logger.warn('Falha ao fazer parse do config (buffer).', { error: error.message });
+      return {};
+    }
+  }
+  if (typeof value === 'string') {
+    try {
+      return JSON.parse(value);
+    } catch (error) {
+      logger.warn('Falha ao fazer parse do config (string).', { error: error.message });
+      return {};
+    }
+  }
+  if (typeof value === 'object') return value;
+  return {};
+};
+
+const loadEnabledGroupsFromDb = async () => {
+  const enabledGroups = [];
+  const limit = 100;
+  let offset = 0;
+
+  while (true) {
+    const rows = await findAll(TABLES.GROUP_CONFIGS, limit, offset);
+    if (!rows.length) break;
+
+    for (const row of rows) {
+      const config = parseConfigValue(row.config);
+      if (config?.newsEnabled) {
+        enabledGroups.push(row.id);
+      }
+    }
+
+    offset += rows.length;
+    if (rows.length < limit) break;
+  }
+
+  return enabledGroups;
+};
+
+const normalizeNewsItems = (data) => {
+  if (!Array.isArray(data)) return [];
+  return data
+    .filter((item) => item && typeof item === 'object')
+    .map((item) => ({
+      id: item.id,
+      timestamp: item.timestamp,
+      refined: item.refined || {},
+    }));
+};
+
+const fetchNewsItems = async () => {
+  try {
+    const response = await axios.get(NEWS_API_URL, { timeout: 15000 });
+    return normalizeNewsItems(response.data);
+  } catch (error) {
+    logger.error('Erro ao buscar noticias da API.', {
+      error: error.message,
+      url: NEWS_API_URL,
+    });
+    return [];
+  }
+};
+
+const buildNewsCaption = (newsItem) => {
+  const title = newsItem?.refined?.name || 'Notícia';
+  const summary = (newsItem?.refined?.summary || '').trim();
+  const url = newsItem?.refined?.url || '';
+
+  const lines = [`📰 *${title}*`];
+  if (summary) {
+    lines.push('', summary);
+  }
+  if (url) {
+    lines.push('', `🔗 ${url}`);
+  }
+  return lines.join('\n').trim();
+};
+
+const sortByTimestampAsc = (items) =>
+  items.sort((a, b) => {
+    const aTime = a?.timestamp ? Date.parse(a.timestamp) : 0;
+    const bTime = b?.timestamp ? Date.parse(b.timestamp) : 0;
+    if (Number.isNaN(aTime) && Number.isNaN(bTime)) return 0;
+    if (Number.isNaN(aTime)) return 1;
+    if (Number.isNaN(bTime)) return -1;
+    return aTime - bTime;
+  });
+
+const trimSentIds = (ids) => {
+  if (!Array.isArray(ids)) return [];
+  if (!Number.isFinite(MAX_SENT_IDS) || MAX_SENT_IDS <= 0) return ids;
+  if (ids.length <= MAX_SENT_IDS) return ids;
+  return ids.slice(ids.length - MAX_SENT_IDS);
+};
+
+const toErrorFragments = (error) => {
+  const candidates = [error?.message, error?.data, error?.output?.payload?.message, error?.output?.payload?.error, error?.output?.statusCode, error?.status, error?.cause?.message, error?.cause?.data];
+
+  return candidates
+    .filter((value) => value !== null && value !== undefined)
+    .map((value) => {
+      if (typeof value === 'string') return value.toLowerCase();
+      if (typeof value === 'number') return String(value);
+      try {
+        return JSON.stringify(value).toLowerCase();
+      } catch {
+        return String(value).toLowerCase();
+      }
+    });
+};
+
+const isGroupUnavailableError = (error) => {
+  const fragments = toErrorFragments(error);
+  return fragments.some((fragment) => GROUP_UNAVAILABLE_ERROR_PATTERNS.some((pattern) => fragment.includes(pattern)));
+};
+
+const scheduleNextRun = (groupId, delayMs) => {
+  const state = groupLoops.get(groupId);
+  if (!state || state.stopped) return;
+  if (state.timeoutId) clearTimeout(state.timeoutId);
+  state.timeoutId = setTimeout(() => {
+    processGroupNews(groupId);
+  }, delayMs);
+};
+
+const stopGroupLoopInternal = (groupId) => {
+  const state = groupLoops.get(groupId);
+  if (!state) return;
+  if (state.timeoutId) clearTimeout(state.timeoutId);
+  state.stopped = true;
+  groupLoops.delete(groupId);
+};
+
+const processGroupNews = async (groupId) => {
+  const state = groupLoops.get(groupId);
+  if (!state || state.stopped) return;
+  if (state.inFlight) return;
+
+  state.inFlight = true;
+  let shouldSchedule = true;
+
+  try {
+    const config = await groupConfigStore.getGroupConfig(groupId);
+    if (!config?.newsEnabled) {
+      shouldSchedule = false;
+      stopGroupLoopInternal(groupId);
+      return;
+    }
+
+    const sock = getActiveSocket();
+    if (!sock) {
+      const now = Date.now();
+      if (!state.lastNotReadyLogAt || now - state.lastNotReadyLogAt > 60_000) {
+        state.lastNotReadyLogAt = now;
+        logger.debug('Socket nao disponivel para envio de noticias.', { groupId });
+      }
+      return;
+    }
+
+    const allNews = await fetchNewsItems();
+    if (allNews.length === 0) {
+      return;
+    }
+
+    const sentIds = new Set(Array.isArray(config.newsSentIds) ? config.newsSentIds : []);
+    const unsent = allNews.filter((item) => item?.id && !sentIds.has(item.id));
+
+    if (unsent.length === 0) {
+      return;
+    }
+
+    sortByTimestampAsc(unsent);
+    const nextItem = unsent[0];
+    const caption = buildNewsCaption(nextItem);
+    const imageUrl = nextItem?.refined?.image || '';
+    let sent = false;
+
+    try {
+      if (imageUrl && /^https?:\/\//i.test(imageUrl)) {
+        let imageBuffer = null;
+        try {
+          imageBuffer = await getImageBuffer(imageUrl);
+        } catch (error) {
+          logger.warn('Falha ao baixar imagem da noticia. Enviando texto.', {
+            groupId,
+            error: error.message,
+            imageUrl,
+          });
+        }
+
+        if (imageBuffer) {
+          try {
+            await sendAndStore(sock, groupId, { image: imageBuffer, caption });
+            sent = true;
+          } catch (error) {
+            if (isGroupUnavailableError(error)) {
+              throw error;
+            }
+            logger.warn('Falha ao enviar imagem da noticia. Enviando texto.', {
+              groupId,
+              error: error.message,
+            });
+          }
+        }
+      }
+
+      if (!sent) {
+        await sendAndStore(sock, groupId, { text: caption });
+      }
+
+      sentIds.add(nextItem.id);
+      const updatedSentIds = trimSentIds(Array.from(sentIds));
+      await groupConfigStore.updateGroupConfig(groupId, {
+        newsSentIds: updatedSentIds,
+        newsLastSentAt: new Date().toISOString(),
+      });
+    } catch (error) {
+      if (isGroupUnavailableError(error)) {
+        shouldSchedule = false;
+        stopGroupLoopInternal(groupId);
+
+        try {
+          await groupConfigStore.updateGroupConfig(groupId, { newsEnabled: false });
+        } catch (updateError) {
+          logger.error('Falha ao desativar noticias para grupo indisponivel.', {
+            groupId,
+            error: updateError.message,
+          });
+        }
+
+        logger.warn('Grupo indisponivel para envio de noticias. Envio automatico desativado.', {
+          groupId,
+          error: error.message,
+        });
+        return;
+      }
+
+      logger.error('Erro ao enviar noticia para grupo.', {
+        groupId,
+        error: error.message,
+      });
+    }
+  } catch (error) {
+    logger.error('Erro no processamento de noticias do grupo.', {
+      groupId,
+      error: error.message,
+    });
+  } finally {
+    state.inFlight = false;
+    if (shouldSchedule) {
+      scheduleNextRun(groupId, getRandomDelayMs());
+    }
+  }
+};
+
+export const startNewsBroadcastForGroup = (groupId, options = {}) => {
+  const existing = groupLoops.get(groupId);
+  if (existing && !existing.stopped) {
+    return;
+  }
+
+  const initialDelay = typeof options.initialDelayMs === 'number' ? options.initialDelayMs : LOOP_START_DELAY_MS;
+
+  groupLoops.set(groupId, {
+    timeoutId: null,
+    inFlight: false,
+    stopped: false,
+  });
+
+  scheduleNextRun(groupId, initialDelay);
+};
+
+export const stopNewsBroadcastForGroup = (groupId) => {
+  stopGroupLoopInternal(groupId);
+};
+
+export const syncNewsBroadcastService = async () => {
+  try {
+    const enabledGroups = await loadEnabledGroupsFromDb();
+    if (enabledGroups.length === 0) {
+      logger.info('Nenhum grupo com noticias ativadas encontrado.');
+      return;
+    }
+
+    enabledGroups.forEach((groupId) => {
+      startNewsBroadcastForGroup(groupId);
+    });
+
+    logger.info('Serviço de noticias sincronizado.', {
+      groups: enabledGroups.length,
+    });
+  } catch (error) {
+    logger.error('Falha ao sincronizar serviço de noticias.', { error: error.message });
+  }
+};
+
+export const initializeNewsBroadcastService = async () => syncNewsBroadcastService();
+
+export const stopNewsBroadcastService = () => {
+  const groupIds = Array.from(groupLoops.keys());
+  if (!groupIds.length) {
+    return;
+  }
+
+  groupIds.forEach((groupId) => stopGroupLoopInternal(groupId));
+  logger.info('Servico de noticias parado.', { groups: groupIds.length });
+};
+
+export const getNewsStatusForGroup = async (groupId) => {
+  const config = await groupConfigStore.getGroupConfig(groupId);
+  const sentCount = Array.isArray(config.newsSentIds) ? config.newsSentIds.length : 0;
+  return {
+    enabled: Boolean(config.newsEnabled),
+    sentCount,
+    lastSentAt: config.newsLastSentAt || null,
+  };
+};

package/app/services/sticker/stickerFocusService.js

@@ -0,0 +1,347 @@
+import { jidNormalizedUser } from '@whiskeysockets/baileys';
+
+const normalizeJid = (jid) => {
+  if (!jid) return '';
+  return jidNormalizedUser(jid);
+};
+
+const parseEnvInt = (value, fallback, min, max) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(numeric)));
+};
+
+export const MIN_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES = 1;
+export const MAX_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES = 24 * 60;
+export const DEFAULT_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES = parseEnvInt(process.env.STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES ?? process.env.STICKER_FOCUS_TEXT_COOLDOWN_MINUTES, 60, MIN_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES, MAX_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES);
+export const MIN_STICKER_FOCUS_MESSAGE_ALLOWANCE = 1;
+export const MAX_STICKER_FOCUS_MESSAGE_ALLOWANCE = 10;
+export const DEFAULT_STICKER_FOCUS_MESSAGE_ALLOWANCE = parseEnvInt(process.env.STICKER_FOCUS_MESSAGE_ALLOWANCE, 2, MIN_STICKER_FOCUS_MESSAGE_ALLOWANCE, MAX_STICKER_FOCUS_MESSAGE_ALLOWANCE);
+
+export const MIN_STICKER_FOCUS_CHAT_WINDOW_MINUTES = 1;
+export const MAX_STICKER_FOCUS_CHAT_WINDOW_MINUTES = 6 * 60;
+export const DEFAULT_STICKER_FOCUS_CHAT_WINDOW_MINUTES = parseEnvInt(process.env.STICKER_FOCUS_CHAT_WINDOW_MINUTES, 15, MIN_STICKER_FOCUS_CHAT_WINDOW_MINUTES, MAX_STICKER_FOCUS_CHAT_WINDOW_MINUTES);
+
+const STICKER_FOCUS_WARNING_COOLDOWN_MS = parseEnvInt(process.env.STICKER_FOCUS_WARNING_COOLDOWN_MS, 45_000, 10_000, 5 * 60_000);
+const NON_HUMAN_PLACEHOLDERS = new Set(['Mensagem vazia', 'Tipo de mensagem não suportado ou sem conteúdo.']);
+const IGNORED_MESSAGE_TYPES = new Set(['messagehistorybundle', 'messagehistorynotice', 'keydistribution', 'senderkeydistribution', 'reaction', 'devicesent', 'contextinfo', 'protocol', 'botinvoke']);
+const NON_THROTTLED_MESSAGE_TYPES = new Set(['sticker', 'image', 'video', 'stickerpack', 'stickerpackmessage']);
+const MESSAGE_WRAPPER_KEYS = ['ephemeralMessage', 'viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension', 'deviceSentMessage', 'editedMessage'];
+
+const sharedMessageAllowance = globalThis.__omnizapStickerFocusMessageAllowance instanceof Map ? globalThis.__omnizapStickerFocusMessageAllowance : new Map();
+const sharedWarningThrottle = globalThis.__omnizapStickerFocusWarningThrottle instanceof Map ? globalThis.__omnizapStickerFocusWarningThrottle : new Map();
+
+globalThis.__omnizapStickerFocusMessageAllowance = sharedMessageAllowance;
+globalThis.__omnizapStickerFocusWarningThrottle = sharedWarningThrottle;
+
+const normalizeMinutes = (value, fallback, min, max) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(numeric)));
+};
+
+const parseTimestampMs = (value) => {
+  if (value === null || value === undefined || value === '') return 0;
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && numeric > 0) return Math.floor(numeric);
+  const parsed = Date.parse(String(value));
+  if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  return 0;
+};
+
+const buildSenderKey = ({ groupId = '', senderJid = '' }) => {
+  const normalizedGroup = normalizeJid(groupId) || String(groupId || '').trim();
+  const normalizedSender = normalizeJid(senderJid) || String(senderJid || '').trim();
+  if (!normalizedGroup || !normalizedSender) return '';
+  return `${normalizedGroup}:${normalizedSender}`;
+};
+
+const hasExplicitTextPayload = (messagePayload) => {
+  if (!messagePayload || typeof messagePayload !== 'object') return false;
+
+  const queue = [messagePayload];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || typeof current !== 'object') continue;
+
+    const conversationText = typeof current.conversation === 'string' ? current.conversation.trim() : '';
+    if (conversationText) return true;
+
+    const extendedText = typeof current.extendedTextMessage?.text === 'string' ? current.extendedTextMessage.text.trim() : '';
+    if (extendedText) return true;
+
+    for (const wrapperKey of MESSAGE_WRAPPER_KEYS) {
+      const nestedMessage = current?.[wrapperKey]?.message;
+      if (nestedMessage && typeof nestedMessage === 'object') {
+        queue.push(nestedMessage);
+      }
+    }
+  }
+
+  return false;
+};
+
+const hasStickerPackPayload = (messagePayload) => {
+  if (!messagePayload || typeof messagePayload !== 'object') return false;
+
+  const queue = [messagePayload];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || typeof current !== 'object') continue;
+
+    if (current.stickerPackMessage && typeof current.stickerPackMessage === 'object') {
+      return true;
+    }
+
+    for (const wrapperKey of MESSAGE_WRAPPER_KEYS) {
+      const nestedMessage = current?.[wrapperKey]?.message;
+      if (nestedMessage && typeof nestedMessage === 'object') {
+        queue.push(nestedMessage);
+      }
+    }
+  }
+
+  return false;
+};
+
+const isPlaceholderOnlyText = (value) => {
+  const normalized = String(value || '').trim();
+  if (!normalized) return true;
+  if (NON_HUMAN_PLACEHOLDERS.has(normalized)) return true;
+  return /^\[[^\]]+\]$/.test(normalized);
+};
+
+const normalizeMessageTypes = (mediaEntries = []) => {
+  if (!Array.isArray(mediaEntries)) return [];
+  return mediaEntries
+    .map((entry) =>
+      String(entry?.mediaType || '')
+        .trim()
+        .toLowerCase(),
+    )
+    .filter(Boolean);
+};
+
+const isIgnoredSystemMessageType = (type) => {
+  const normalized = String(type || '')
+    .trim()
+    .toLowerCase();
+  if (!normalized) return true;
+  if (IGNORED_MESSAGE_TYPES.has(normalized)) return true;
+  // Cobre variações do Baileys/proto para eventos internos de distribuição de chave.
+  if (normalized.includes('keydistribution')) return true;
+  if (normalized.includes('senderkeydistribution')) return true;
+  return false;
+};
+
+const isAlbumMediaMessageType = (type) => {
+  const normalized = String(type || '')
+    .trim()
+    .toLowerCase();
+  if (!normalized) return false;
+  if (normalized === 'album') return true;
+  return normalized.startsWith('album');
+};
+
+export const clampStickerFocusMessageCooldownMinutes = (value, fallback = DEFAULT_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES) => normalizeMinutes(value, fallback, MIN_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES, MAX_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES);
+export const clampStickerFocusMessageAllowance = (value, fallback = DEFAULT_STICKER_FOCUS_MESSAGE_ALLOWANCE) => normalizeMinutes(value, fallback, MIN_STICKER_FOCUS_MESSAGE_ALLOWANCE, MAX_STICKER_FOCUS_MESSAGE_ALLOWANCE);
+
+export const clampStickerFocusChatWindowMinutes = (value, fallback = DEFAULT_STICKER_FOCUS_CHAT_WINDOW_MINUTES) => normalizeMinutes(value, fallback, MIN_STICKER_FOCUS_CHAT_WINDOW_MINUTES, MAX_STICKER_FOCUS_CHAT_WINDOW_MINUTES);
+
+export const minutesToMs = (minutes) => Math.max(0, Math.floor(Number(minutes) || 0) * 60 * 1000);
+
+export const resolveStickerFocusState = (groupConfig = {}, now = Date.now()) => {
+  const rawCooldown = groupConfig?.stickerFocusMessageCooldownMinutes ?? groupConfig?.stickerFocusTextCooldownMinutes;
+  const messageCooldownMinutes = clampStickerFocusMessageCooldownMinutes(rawCooldown);
+  const rawAllowance = groupConfig?.stickerFocusMessageAllowance ?? groupConfig?.stickerFocusMessageAllowanceCount;
+  const messageAllowanceCount = clampStickerFocusMessageAllowance(rawAllowance);
+  const messageCooldownMs = minutesToMs(messageCooldownMinutes);
+  const chatWindowUntilMs = parseTimestampMs(groupConfig?.stickerFocusChatWindowUntilMs);
+  const safeNow = Number.isFinite(now) ? now : Date.now();
+  const chatWindowRemainingMs = Math.max(0, chatWindowUntilMs - safeNow);
+
+  return {
+    enabled: Boolean(groupConfig?.stickerFocusEnabled),
+    messageAllowanceCount,
+    messageCooldownMinutes,
+    messageCooldownMs,
+    // backward compatibility for old reads
+    textAllowanceCount: messageAllowanceCount,
+    textCooldownMinutes: messageCooldownMinutes,
+    textCooldownMs: messageCooldownMs,
+    chatWindowUntilMs,
+    chatWindowRemainingMs,
+    isChatWindowOpen: chatWindowRemainingMs > 0,
+  };
+};
+
+export const resolveStickerFocusMessageClassification = ({ messageInfo, extractedText, mediaEntries = [] }) => {
+  if (messageInfo?.messageStubType !== undefined && messageInfo?.messageStubType !== null) {
+    return {
+      isThrottleCandidate: false,
+      messageType: 'system_stub',
+      reason: 'stub',
+    };
+  }
+
+  if (hasStickerPackPayload(messageInfo?.message)) {
+    return {
+      isThrottleCandidate: false,
+      messageType: 'sticker_pack',
+      reason: 'sticker_pack_payload',
+    };
+  }
+
+  const messageTypes = normalizeMessageTypes(mediaEntries);
+  const filteredTypes = messageTypes.filter((type) => !isIgnoredSystemMessageType(type));
+  const primaryType = filteredTypes[0] || messageTypes[0] || 'unknown';
+  const nonThrottledType = filteredTypes.find((type) => NON_THROTTLED_MESSAGE_TYPES.has(type) || isAlbumMediaMessageType(type));
+
+  if (nonThrottledType) {
+    return {
+      isThrottleCandidate: false,
+      messageType: nonThrottledType || primaryType,
+      reason: 'sticker_flow_media',
+    };
+  }
+
+  if (filteredTypes.length > 0) {
+    return {
+      isThrottleCandidate: true,
+      messageType: primaryType,
+      reason: 'message_type',
+    };
+  }
+
+  if (!isPlaceholderOnlyText(extractedText) && hasExplicitTextPayload(messageInfo?.message)) {
+    return {
+      isThrottleCandidate: true,
+      messageType: 'text',
+      reason: 'explicit_text_payload',
+    };
+  }
+
+  return {
+    isThrottleCandidate: false,
+    messageType: primaryType,
+    reason: 'non_human_or_empty',
+  };
+};
+
+const normalizeAllowanceHistory = (historyValue) => {
+  if (Array.isArray(historyValue)) {
+    return historyValue
+      .map((entry) => Number(entry))
+      .filter((entry) => Number.isFinite(entry) && entry > 0)
+      .map((entry) => Math.floor(entry))
+      .sort((a, b) => a - b);
+  }
+
+  const singleTimestamp = Number(historyValue);
+  if (Number.isFinite(singleTimestamp) && singleTimestamp > 0) {
+    return [Math.floor(singleTimestamp)];
+  }
+
+  return [];
+};
+
+export const canSendMessageInStickerFocus = ({ groupId, senderJid, messageCooldownMs, messageAllowanceCount = DEFAULT_STICKER_FOCUS_MESSAGE_ALLOWANCE, now = Date.now() }) => {
+  const senderKey = buildSenderKey({ groupId, senderJid });
+  if (!senderKey) {
+    return {
+      allowed: true,
+      remainingMs: 0,
+      usageCount: 0,
+      allowanceCount: clampStickerFocusMessageAllowance(messageAllowanceCount),
+    };
+  }
+
+  const normalizedCooldownMs = Math.max(0, Math.floor(Number(messageCooldownMs) || 0));
+  const normalizedAllowanceCount = clampStickerFocusMessageAllowance(messageAllowanceCount);
+  if (normalizedCooldownMs <= 0) {
+    const rawHistory = normalizeAllowanceHistory(sharedMessageAllowance.get(senderKey));
+    return {
+      allowed: true,
+      remainingMs: 0,
+      usageCount: rawHistory.length,
+      allowanceCount: normalizedAllowanceCount,
+    };
+  }
+
+  const safeNow = Number.isFinite(now) ? now : Date.now();
+  const history = normalizeAllowanceHistory(sharedMessageAllowance.get(senderKey)).filter((timestamp) => safeNow - timestamp < normalizedCooldownMs);
+  if (history.length > 0) {
+    sharedMessageAllowance.set(senderKey, history);
+  } else {
+    sharedMessageAllowance.delete(senderKey);
+  }
+
+  if (history.length < normalizedAllowanceCount) {
+    return {
+      allowed: true,
+      remainingMs: 0,
+      usageCount: history.length,
+      allowanceCount: normalizedAllowanceCount,
+    };
+  }
+
+  const oldestTimestamp = history[0] || safeNow;
+  return {
+    allowed: false,
+    remainingMs: Math.max(0, normalizedCooldownMs - (safeNow - oldestTimestamp)),
+    usageCount: history.length,
+    allowanceCount: normalizedAllowanceCount,
+  };
+};
+
+export const registerMessageUsageInStickerFocus = ({ groupId, senderJid, messageCooldownMs = minutesToMs(DEFAULT_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES), messageAllowanceCount = DEFAULT_STICKER_FOCUS_MESSAGE_ALLOWANCE, now = Date.now() }) => {
+  const senderKey = buildSenderKey({ groupId, senderJid });
+  if (!senderKey) return;
+  const normalizedCooldownMs = Math.max(0, Math.floor(Number(messageCooldownMs) || 0));
+  const normalizedAllowanceCount = clampStickerFocusMessageAllowance(messageAllowanceCount);
+  const safeNow = Number.isFinite(now) ? now : Date.now();
+  const history = normalizeAllowanceHistory(sharedMessageAllowance.get(senderKey));
+  const recentHistory = normalizedCooldownMs > 0 ? history.filter((timestamp) => safeNow - timestamp < normalizedCooldownMs) : history;
+  recentHistory.push(safeNow);
+  const trimmedHistory = recentHistory.slice(-normalizedAllowanceCount);
+  sharedMessageAllowance.set(senderKey, trimmedHistory);
+};
+
+export const shouldSendStickerFocusWarning = ({ groupId, senderJid, now = Date.now() }) => {
+  const senderKey = buildSenderKey({ groupId, senderJid });
+  if (!senderKey) return true;
+  const safeNow = Number.isFinite(now) ? now : Date.now();
+  const lastWarningAt = Number(sharedWarningThrottle.get(senderKey) || 0);
+  if (!lastWarningAt || safeNow - lastWarningAt >= STICKER_FOCUS_WARNING_COOLDOWN_MS) {
+    sharedWarningThrottle.set(senderKey, safeNow);
+    return true;
+  }
+  return false;
+};
+
+// Backward compatibility aliases
+export const MIN_STICKER_FOCUS_TEXT_COOLDOWN_MINUTES = MIN_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES;
+export const MAX_STICKER_FOCUS_TEXT_COOLDOWN_MINUTES = MAX_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES;
+export const DEFAULT_STICKER_FOCUS_TEXT_COOLDOWN_MINUTES = DEFAULT_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES;
+export const clampStickerFocusTextCooldownMinutes = clampStickerFocusMessageCooldownMinutes;
+export const MIN_STICKER_FOCUS_TEXT_ALLOWANCE = MIN_STICKER_FOCUS_MESSAGE_ALLOWANCE;
+export const MAX_STICKER_FOCUS_TEXT_ALLOWANCE = MAX_STICKER_FOCUS_MESSAGE_ALLOWANCE;
+export const DEFAULT_STICKER_FOCUS_TEXT_ALLOWANCE = DEFAULT_STICKER_FOCUS_MESSAGE_ALLOWANCE;
+export const clampStickerFocusTextAllowance = clampStickerFocusMessageAllowance;
+export const isPlainTextMessageForStickerFocus = ({ messageInfo, extractedText, mediaEntries = [] }) => resolveStickerFocusMessageClassification({ messageInfo, extractedText, mediaEntries }).messageType === 'text';
+export const canSendTextInStickerFocus = ({ groupId, senderJid, textCooldownMs, textAllowanceCount, now = Date.now() }) =>
+  canSendMessageInStickerFocus({
+    groupId,
+    senderJid,
+    messageCooldownMs: textCooldownMs,
+    messageAllowanceCount: textAllowanceCount,
+    now,
+  });
+export const registerTextUsageInStickerFocus = ({ groupId, senderJid, textCooldownMs, textAllowanceCount, now = Date.now() }) =>
+  registerMessageUsageInStickerFocus({
+    groupId,
+    senderJid,
+    messageCooldownMs: textCooldownMs,
+    messageAllowanceCount: textAllowanceCount,
+    now,
+  });