@omnizap-system/omnizap 2.6.1 → 2.6.2

package/app/modules/adminModule/groupCommandHandlers.js

@@ -5,15 +5,16 @@ import { isUserAdmin, createGroup, acceptGroupInvite, getGroupInfo, getGroupRequ
 import groupConfigStore from '../../store/groupConfigStore.js';
 import premiumUserStore from '../../store/premiumUserStore.js';
 import logger from '#logger';
-import { KNOWN_NETWORKS } from '../../utils/antiLink/antiLinkModule.js';
+import { KNOWN_NETWORKS, purgeRecentMessagesForSenderCandidates } from '../../utils/antiLink/antiLinkModule.js';
 import { getNewsStatusForGroup, startNewsBroadcastForGroup, stopNewsBroadcastForGroup } from '../../services/messaging/newsBroadcastService.js';
 import { sendAndStore } from '../../services/messaging/messagePersistenceService.js';
 import { clearCaptchasForGroup } from '../../services/messaging/captchaService.js';
 import { getAdminJid, isAdminSenderAsync } from '../../config/index.js';
 import { extractUserIdInfo, resolveUserId } from '../../config/index.js';
-import { DEFAULT_STICKER_FOCUS_CHAT_WINDOW_MINUTES, DEFAULT_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES, MAX_STICKER_FOCUS_CHAT_WINDOW_MINUTES, MAX_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES, MIN_STICKER_FOCUS_CHAT_WINDOW_MINUTES, MIN_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES, clampStickerFocusChatWindowMinutes, clampStickerFocusMessageCooldownMinutes, resolveStickerFocusState } from '../../services/sticker/stickerFocusService.js';
+import { DEFAULT_STICKER_FOCUS_CHAT_WINDOW_MINUTES, DEFAULT_STICKER_FOCUS_MESSAGE_ALLOWANCE, DEFAULT_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES, MAX_STICKER_FOCUS_CHAT_WINDOW_MINUTES, MAX_STICKER_FOCUS_MESSAGE_ALLOWANCE, MAX_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES, MIN_STICKER_FOCUS_CHAT_WINDOW_MINUTES, MIN_STICKER_FOCUS_MESSAGE_ALLOWANCE, MIN_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES, clampStickerFocusChatWindowMinutes, clampStickerFocusMessageAllowance, clampStickerFocusMessageCooldownMinutes, resolveStickerFocusState } from '../../services/sticker/stickerFocusService.js';
 import { getAdminTextConfig, getAdminUsageText, isAdminCommandName, resolveAdminCommandName } from './adminConfigRuntime.js';
 import { explicarComando, gerarFaqAutomatica, responderPergunta, startAdminAiHelpScheduler } from './adminAiHelpService.js';
+import { addGroupWarning, clearGroupWarnings, countGroupWarnings, listGroupWarnings } from './groupWarningRepository.js';
 const OWNER_JID = getAdminJid();
 const DEFAULT_COMMAND_PREFIX = process.env.COMMAND_PREFIX || '/';
 const ADMIN_TEXTS = getAdminTextConfig();
@@ -21,6 +22,11 @@ const GROUP_ONLY_COMMAND_MESSAGE = ADMIN_TEXTS.group_only_command_message;
 const NO_PERMISSION_COMMAND_MESSAGE = ADMIN_TEXTS.no_permission_command_message;
 const OWNER_ONLY_COMMAND_MESSAGE = ADMIN_TEXTS.owner_only_command_message;
 const USER_JID_SERVERS = new Set([...WHATSAPP_USER_JID_SERVERS, ...LID_USER_JID_SERVERS]);
+const MAX_WARN_REASON_CHARS = 500;
+const WARNINGS_LIST_PREVIEW_LIMIT = 8;
+const DEFAULT_WARN_AUTO_BAN_THRESHOLD = 3;
+const MIN_WARN_AUTO_BAN_THRESHOLD = 1;
+const MAX_WARN_AUTO_BAN_THRESHOLD = 50;
 const normalizePhoneDigits = (value) => String(value || '').replace(/\D+/g, '');
 
 const LEGACY_ADMIN_ROUTE_BY_CANONICAL = {
@@ -106,6 +112,94 @@ const getParticipantJids = (messageInfo, args) => {
   return dedupeParticipantJids(args);
 };
 
+const normalizeWarnReason = (value) =>
+  String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, MAX_WARN_REASON_CHARS);
+
+const formatUserMentionToken = (jid) => {
+  const userPart = String(jid || '')
+    .split('@')[0]
+    .trim();
+  return userPart ? `@${userPart}` : '@usuario';
+};
+
+const formatWarnTimestamp = (value) => {
+  if (!value) return 'data desconhecida';
+  const parsed = Date.parse(String(value));
+  if (!Number.isFinite(parsed)) return String(value);
+  return new Date(parsed).toLocaleString('pt-BR');
+};
+
+const resolveSingleTargetFromMessage = (messageInfo, args = []) => {
+  const safeArgs = Array.isArray(args) ? args.map((value) => String(value || '').trim()).filter(Boolean) : [];
+  const contextInfo = messageInfo?.message?.extendedTextMessage?.contextInfo || {};
+  const mentionedJids = dedupeParticipantJids(contextInfo?.mentionedJid || []);
+
+  if (mentionedJids.length > 1) {
+    return {
+      targetJid: '',
+      remainingArgs: safeArgs,
+      multipleTargets: true,
+    };
+  }
+
+  if (mentionedJids.length === 1) {
+    const targetJid = mentionedJids[0];
+    const remainingArgs = [...safeArgs];
+
+    while (remainingArgs.length > 0) {
+      const token = String(remainingArgs[0] || '').trim();
+      if (!token) {
+        remainingArgs.shift();
+        continue;
+      }
+
+      const normalizedToken = normalizeParticipantJid(token);
+      if (normalizedToken && (normalizedToken === targetJid || isSameJidUser(normalizedToken, targetJid))) {
+        remainingArgs.shift();
+        continue;
+      }
+      if (token.startsWith('@')) {
+        remainingArgs.shift();
+        continue;
+      }
+      break;
+    }
+
+    return {
+      targetJid,
+      remainingArgs,
+      multipleTargets: false,
+    };
+  }
+
+  const firstArgTarget = normalizeParticipantJid(safeArgs[0] || '');
+  if (firstArgTarget) {
+    return {
+      targetJid: firstArgTarget,
+      remainingArgs: safeArgs.slice(1),
+      multipleTargets: false,
+    };
+  }
+
+  const repliedTo = dedupeParticipantJids([contextInfo?.participant || '']);
+  if (repliedTo.length === 1) {
+    return {
+      targetJid: repliedTo[0],
+      remainingArgs: safeArgs,
+      multipleTargets: false,
+    };
+  }
+
+  return {
+    targetJid: '',
+    remainingArgs: safeArgs,
+    multipleTargets: false,
+  };
+};
+
 const resolvePremiumTargetJid = async (targetJid) => {
   const normalizedTarget = normalizeParticipantJid(targetJid);
   if (!normalizedTarget) return '';
@@ -149,6 +243,12 @@ const parsePositiveInteger = (value) => {
   return normalized;
 };
 
+const clampWarnAutoBanThreshold = (value) => {
+  const parsed = parsePositiveInteger(value);
+  if (!parsed) return DEFAULT_WARN_AUTO_BAN_THRESHOLD;
+  return Math.max(MIN_WARN_AUTO_BAN_THRESHOLD, Math.min(MAX_WARN_AUTO_BAN_THRESHOLD, parsed));
+};
+
 const formatStickerFocusRule = ({ messageAllowanceCount, messageCooldownMinutes }) => {
   const allowanceCount = Math.max(1, Math.floor(Number(messageAllowanceCount) || 1));
   const cooldownMinutes = Math.max(1, Math.floor(Number(messageCooldownMinutes) || 1));
@@ -163,6 +263,96 @@ const buildStickerFocusStatusText = ({ state, commandPrefix }) => {
   return ['🖼️ *Status do modo Sticker*', '', `Modo sticker: *${state.enabled ? 'ativado' : 'desativado'}*`, `Janela de chat: *${chatWindowStatus}*`, `Regra fora da janela: *${formatStickerFocusRule(state)}*`, '', `Comandos:`, `${commandPrefix}stickermode <on|off|status>`, `${commandPrefix}chatwindow <on|off|status> [minutos]`, `${commandPrefix}stickermsglimit <minutos|status|reset>`].join('\n');
 };
 
+const formatListForMessage = (items = [], emptyLabel = 'nenhum') => {
+  const safeItems = Array.isArray(items) ? items.map((item) => String(item || '').trim()).filter(Boolean) : [];
+  return safeItems.length ? safeItems.join(', ') : emptyLabel;
+};
+
+const parseFilterValues = (values = []) => {
+  const rawText = Array.isArray(values) ? values.join(' ') : String(values || '');
+  if (!rawText.trim()) return [];
+  const normalized = rawText
+    .split(/[\s,]+/)
+    .map((value) =>
+      String(value || '')
+        .trim()
+        .toLowerCase(),
+    )
+    .filter(Boolean);
+  return Array.from(new Set(normalized)).sort((left, right) => left.localeCompare(right));
+};
+
+const normalizeStringList = (value) => {
+  const source = Array.isArray(value) ? value : typeof value === 'string' ? value.split(',') : [];
+  return source
+    .map((entry) =>
+      String(entry || '')
+        .trim()
+        .toLowerCase(),
+    )
+    .filter(Boolean);
+};
+
+const normalizeNewsFilterState = (groupConfig = {}) => {
+  const nested = groupConfig?.newsFilters && typeof groupConfig.newsFilters === 'object' ? groupConfig.newsFilters : {};
+  const sourceIds = Array.from(new Set([...normalizeStringList(groupConfig.newsSources), ...normalizeStringList(groupConfig.newsSourceIds), ...normalizeStringList(nested.sources), ...normalizeStringList(nested.sourceIds)])).sort((left, right) => left.localeCompare(right));
+  const franchiseSlugs = Array.from(new Set([...normalizeStringList(groupConfig.newsFranchises), ...normalizeStringList(groupConfig.newsFranchiseSlugs), ...normalizeStringList(nested.franchises), ...normalizeStringList(nested.franchiseSlugs)])).sort((left, right) => left.localeCompare(right));
+  const entitySlugs = Array.from(new Set([...normalizeStringList(groupConfig.newsEntities), ...normalizeStringList(groupConfig.newsEntitySlugs), ...normalizeStringList(groupConfig.newsTags), ...normalizeStringList(nested.entities), ...normalizeStringList(nested.entitySlugs), ...normalizeStringList(nested.tags)])).sort((left, right) => left.localeCompare(right));
+  const onlyTrending = Boolean(groupConfig.newsOnlyTrending || nested.onlyTrending);
+
+  return {
+    sourceIds,
+    franchiseSlugs,
+    entitySlugs,
+    onlyTrending,
+  };
+};
+
+const buildNewsFilterConfigPatch = (groupConfig, nextState) => {
+  const nested = groupConfig?.newsFilters && typeof groupConfig.newsFilters === 'object' ? groupConfig.newsFilters : {};
+  const safeSources = Array.isArray(nextState?.sourceIds) ? nextState.sourceIds : [];
+  const safeFranchises = Array.isArray(nextState?.franchiseSlugs) ? nextState.franchiseSlugs : [];
+  const safeEntities = Array.isArray(nextState?.entitySlugs) ? nextState.entitySlugs : [];
+  const safeOnlyTrending = Boolean(nextState?.onlyTrending);
+
+  return {
+    newsSourceIds: safeSources,
+    newsSources: safeSources,
+    newsFranchiseSlugs: safeFranchises,
+    newsFranchises: safeFranchises,
+    newsEntitySlugs: safeEntities,
+    newsEntities: safeEntities,
+    newsTags: safeEntities,
+    newsOnlyTrending: safeOnlyTrending,
+    newsFilters: {
+      ...nested,
+      sourceIds: safeSources,
+      sources: safeSources,
+      franchiseSlugs: safeFranchises,
+      franchises: safeFranchises,
+      entitySlugs: safeEntities,
+      entities: safeEntities,
+      tags: safeEntities,
+      onlyTrending: safeOnlyTrending,
+    },
+  };
+};
+
+const formatDateTimeLabel = (value) => {
+  if (!value) return 'nunca';
+  const parsed = Date.parse(String(value));
+  if (!Number.isFinite(parsed)) return String(value);
+  return new Date(parsed).toLocaleString('pt-BR');
+};
+
+const buildGroupAuditText = ({ config, stickerState, newsStatus, commandPrefix }) => {
+  const prefix = String(config?.commandPrefix || '').trim() || DEFAULT_COMMAND_PREFIX;
+  const newsFilters = normalizeNewsFilterState(config);
+  const stickerWindowText = stickerState.isChatWindowOpen ? `aberta (~${Math.max(1, Math.ceil(stickerState.chatWindowRemainingMs / (60 * 1000)))} min restantes)` : 'fechada';
+
+  return ['🧾 *Auditoria do Grupo*', '', `Prefixo: *${prefix}*`, `NSFW: *${config?.nsfwEnabled ? 'ativado' : 'desativado'}*`, `AutoSticker: *${config?.autoStickerEnabled ? 'ativado' : 'desativado'}*`, `Modo Sticker: *${stickerState.enabled ? 'ativado' : 'desativado'}*`, `Janela de chat: *${stickerWindowText}*`, `Regra de texto: *${formatStickerFocusRule(stickerState)}*`, `Captcha: *${config?.captchaEnabled ? 'ativado' : 'desativado'}*`, `Auto-aprovação de solicitações: *${config?.autoApproveRequestsEnabled ? 'ativada' : 'desativada'}*`, `Antilink: *${config?.antilinkEnabled ? 'ativado' : 'desativado'}*`, `Antilink redes permitidas: ${formatListForMessage(config?.antilinkAllowedNetworks || [])}`, `Antilink domínios permitidos: ${formatListForMessage(config?.antilinkAllowedDomains || [])}`, `Notícias: *${newsStatus?.enabled ? 'ativado' : 'desativado'}*`, `Notícias enviadas: *${Number(newsStatus?.sentCount || 0)}*`, `Último envio de notícias: *${formatDateTimeLabel(newsStatus?.lastSentAt)}*`, `Filtro notícias [source]: ${formatListForMessage(newsFilters.sourceIds)}`, `Filtro notícias [franchise]: ${formatListForMessage(newsFilters.franchiseSlugs)}`, `Filtro notícias [tag/entity]: ${formatListForMessage(newsFilters.entitySlugs)}`, `Filtro notícias [somente em alta]: *${newsFilters.onlyTrending ? 'sim' : 'não'}*`, `Boas-vindas: *${config?.welcomeMessageEnabled ? 'ativadas' : 'desativadas'}*`, `Despedida: *${config?.farewellMessageEnabled ? 'ativadas' : 'desativadas'}*`, '', `Dica: use *${commandPrefix}noticiasfiltro status* para ver os filtros em detalhe.`].join('\n');
+};
+
 export const isAdminCommand = (command) => isAdminCommandName(command);
 
 export async function handleAdminCommand({ command, args, text, sock, messageInfo, remoteJid, senderJid, botJid, isGroupMessage, expirationMessage, commandPrefix = DEFAULT_COMMAND_PREFIX }) {
@@ -194,7 +384,7 @@ export async function handleAdminCommand({ command, args, text, sock, messageInf
       const isOwner = Boolean(OWNER_JID && (await isAdminSenderAsync(senderIdentity)));
 
       if (!subAction) {
-        await handleMenuAdmCommand(sock, remoteJid, messageInfo, expirationMessage, commandPrefix);
+        await handleMenuAdmCommand(sock, remoteJid, messageInfo, expirationMessage, commandPrefix, []);
         break;
       }
 
@@ -265,14 +455,7 @@ export async function handleAdminCommand({ command, args, text, sock, messageInf
         break;
       }
 
-      await sendAndStore(
-        sock,
-        remoteJid,
-        {
-          text: getAdminUsageText('menuadm', { commandPrefix, variant: 'default' }),
-        },
-        { quoted: messageInfo, ephemeralExpiration: expirationMessage },
-      );
+      await handleMenuAdmCommand(sock, remoteJid, messageInfo, expirationMessage, commandPrefix, args);
       break;
     }
 
@@ -627,7 +810,6 @@ export async function handleAdminCommand({ command, args, text, sock, messageInf
       if (['reset', 'default', 'padrao', 'padrão'].includes(normalized)) {
         await groupConfigStore.updateGroupConfig(remoteJid, {
           stickerFocusMessageCooldownMinutes: DEFAULT_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES,
-          // compatibilidade com configuração antiga
           stickerFocusTextCooldownMinutes: DEFAULT_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES,
         });
         await sendAndStore(
@@ -669,7 +851,6 @@ export async function handleAdminCommand({ command, args, text, sock, messageInf
       const minutes = clampStickerFocusMessageCooldownMinutes(parsed, DEFAULT_STICKER_FOCUS_MESSAGE_COOLDOWN_MINUTES);
       await groupConfigStore.updateGroupConfig(remoteJid, {
         stickerFocusMessageCooldownMinutes: minutes,
-        // compatibilidade com configuração antiga
         stickerFocusTextCooldownMinutes: minutes,
       });
 
@@ -684,6 +865,93 @@ export async function handleAdminCommand({ command, args, text, sock, messageInf
       break;
     }
 
+    case 'stickerallowance': {
+      if (!isGroupMessage) {
+        await sendAndStore(sock, remoteJid, { text: GROUP_ONLY_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+      if (!(await isUserAdmin(remoteJid, senderIdentity))) {
+        await sendAndStore(sock, remoteJid, { text: NO_PERMISSION_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+
+      const rawValue = args[0];
+      const normalized = String(rawValue || '')
+        .trim()
+        .toLowerCase();
+
+      if (!normalized || normalized === 'status') {
+        const config = await groupConfigStore.getGroupConfig(remoteJid);
+        const state = resolveStickerFocusState(config);
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: `📏 Limite atual de mensagens por usuário no modo sticker: *${state.messageAllowanceCount}*.` + `\nRegra vigente: *${formatStickerFocusRule(state)}*.` + `\nUse *${commandPrefix}stickerallowance <quantidade>* para alterar.`,
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      if (['reset', 'default', 'padrao', 'padrão'].includes(normalized)) {
+        await groupConfigStore.updateGroupConfig(remoteJid, {
+          stickerFocusMessageAllowance: DEFAULT_STICKER_FOCUS_MESSAGE_ALLOWANCE,
+          stickerFocusMessageAllowanceCount: DEFAULT_STICKER_FOCUS_MESSAGE_ALLOWANCE,
+        });
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: `✅ Limite restaurado para o padrão: *${DEFAULT_STICKER_FOCUS_MESSAGE_ALLOWANCE}* mensagem(ns) por janela.`,
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const parsed = parsePositiveInteger(rawValue);
+      if (!parsed) {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: getAdminUsageText('stickerallowance', { commandPrefix }),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      if (parsed < MIN_STICKER_FOCUS_MESSAGE_ALLOWANCE || parsed > MAX_STICKER_FOCUS_MESSAGE_ALLOWANCE) {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: `Informe uma quantidade entre ${MIN_STICKER_FOCUS_MESSAGE_ALLOWANCE} e ${MAX_STICKER_FOCUS_MESSAGE_ALLOWANCE}.`,
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const allowance = clampStickerFocusMessageAllowance(parsed, DEFAULT_STICKER_FOCUS_MESSAGE_ALLOWANCE);
+      await groupConfigStore.updateGroupConfig(remoteJid, {
+        stickerFocusMessageAllowance: allowance,
+        stickerFocusMessageAllowanceCount: allowance,
+      });
+
+      await sendAndStore(
+        sock,
+        remoteJid,
+        {
+          text: `✅ Limite de mensagens por usuário atualizado para *${allowance}* no modo sticker.`,
+        },
+        { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+      );
+      break;
+    }
+
     case 'newgroup': {
       if (args.length < 2) {
         await sendAndStore(
@@ -766,7 +1034,33 @@ export async function handleAdminCommand({ command, args, text, sock, messageInf
       }
       try {
         await updateGroupParticipants(sock, remoteJid, participants, 'remove');
-        await sendAndStore(sock, remoteJid, { text: 'Participantes removidos com sucesso.' }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+
+        let deletedRecentMessages = 0;
+        let failedRecentDeletes = 0;
+        let requestedRecentDeletes = 0;
+        for (const participant of participants) {
+          const cleanupResult = await purgeRecentMessagesForSenderCandidates({
+            sock,
+            remoteJid,
+            senderCandidates: [participant],
+          });
+          deletedRecentMessages += Number(cleanupResult?.deleted || 0);
+          failedRecentDeletes += Number(cleanupResult?.failed || 0);
+          requestedRecentDeletes += Number(cleanupResult?.requested || 0);
+        }
+
+        const successText = deletedRecentMessages > 0 ? `Participantes removidos com sucesso.\n🧹 ${deletedRecentMessages} mensagem(ns) recentes apagadas.` : 'Participantes removidos com sucesso.';
+        await sendAndStore(sock, remoteJid, { text: successText }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+
+        logger.info('Comando ban executado com limpeza de mensagens recentes.', {
+          action: 'admin_ban_with_recent_cleanup',
+          groupId: remoteJid,
+          participants,
+          deletedRecentMessages,
+          failedRecentDeletes,
+          requestedRecentDeletes,
+        });
+
         const repliedTo = messageInfo.message?.extendedTextMessage?.contextInfo;
         if (repliedTo && containsParticipantJid(participants, repliedTo.participant)) {
           await sendAndStore(sock, remoteJid, {
@@ -779,6 +1073,329 @@ export async function handleAdminCommand({ command, args, text, sock, messageInf
       break;
     }
 
+    case 'warn': {
+      if (!isGroupMessage) {
+        await sendAndStore(sock, remoteJid, { text: GROUP_ONLY_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+      if (!(await isUserAdmin(remoteJid, senderIdentity))) {
+        await sendAndStore(sock, remoteJid, { text: NO_PERMISSION_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+
+      const { targetJid, remainingArgs, multipleTargets } = resolveSingleTargetFromMessage(messageInfo, args);
+      if (multipleTargets || !targetJid) {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: getAdminUsageText('warn', { commandPrefix, variant: 'missing_targets' }),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const reason = normalizeWarnReason(remainingArgs.join(' '));
+      const targetMention = formatUserMentionToken(targetJid);
+
+      try {
+        await addGroupWarning({
+          groupId: remoteJid,
+          participantJid: targetJid,
+          warnedByJid: senderJid,
+          reason: reason || null,
+        });
+
+        const totalWarnings = await countGroupWarnings({
+          groupId: remoteJid,
+          participantJid: targetJid,
+        });
+
+        const groupConfig = await groupConfigStore.getGroupConfig(remoteJid);
+        const warnAutoBanThreshold = clampWarnAutoBanThreshold(groupConfig?.warnAutoBanThreshold);
+        const shouldAutoBan = totalWarnings >= warnAutoBanThreshold && !containsParticipantJid([targetJid], botJid);
+        let autoBanSucceeded = false;
+        let autoBanError = '';
+
+        if (shouldAutoBan) {
+          try {
+            await updateGroupParticipants(sock, remoteJid, [targetJid], 'remove');
+            autoBanSucceeded = true;
+          } catch (error) {
+            autoBanError = error?.message || 'falha desconhecida';
+            logger.warn('Falha ao aplicar auto-ban por limite de advertências.', {
+              action: 'admin_warn_auto_ban_failed',
+              groupId: remoteJid,
+              targetJid,
+              warnAutoBanThreshold,
+              totalWarnings,
+              error: autoBanError,
+            });
+          }
+        }
+
+        const replyLines = [`⚠️ Advertência registrada para ${targetMention}.`, `Motivo: ${reason || 'não informado'}`, `Total de advertências neste grupo: *${totalWarnings}*.`, `Auto-ban configurado para: *${warnAutoBanThreshold}* advertência(s).`];
+        if (autoBanSucceeded) {
+          replyLines.push(`🚫 Limite atingido: ${targetMention} foi removido(a) automaticamente do grupo.`);
+        } else if (autoBanError) {
+          replyLines.push(`⚠️ Limite atingido, mas não consegui remover automaticamente: ${autoBanError}`);
+        }
+
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: replyLines.join('\n'),
+            mentions: [targetJid],
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+      } catch (error) {
+        logger.warn('Falha ao registrar advertência no grupo.', {
+          action: 'admin_warn_failed',
+          groupId: remoteJid,
+          senderJid,
+          targetJid,
+          error: error?.message,
+        });
+        await sendAndStore(sock, remoteJid, { text: `Não foi possível registrar a advertência. Detalhes: ${error.message}` }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+      }
+      break;
+    }
+
+    case 'warnings': {
+      if (!isGroupMessage) {
+        await sendAndStore(sock, remoteJid, { text: GROUP_ONLY_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+      if (!(await isUserAdmin(remoteJid, senderIdentity))) {
+        await sendAndStore(sock, remoteJid, { text: NO_PERMISSION_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+
+      const { targetJid, multipleTargets } = resolveSingleTargetFromMessage(messageInfo, args);
+      if (multipleTargets || !targetJid) {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: getAdminUsageText('warnings', { commandPrefix, variant: 'missing_targets' }),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const targetMention = formatUserMentionToken(targetJid);
+
+      try {
+        const [totalWarnings, warningRows] = await Promise.all([
+          countGroupWarnings({
+            groupId: remoteJid,
+            participantJid: targetJid,
+          }),
+          listGroupWarnings({
+            groupId: remoteJid,
+            participantJid: targetJid,
+            limit: WARNINGS_LIST_PREVIEW_LIMIT,
+          }),
+        ]);
+
+        if (totalWarnings <= 0) {
+          await sendAndStore(
+            sock,
+            remoteJid,
+            {
+              text: `✅ ${targetMention} não possui advertências registradas neste grupo.`,
+              mentions: [targetJid],
+            },
+            { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+          );
+          break;
+        }
+
+        const historyLines = (warningRows || []).map((warningRow, index) => `${index + 1}. ${formatWarnTimestamp(warningRow?.createdAt)} - ${warningRow?.reason || 'Sem motivo informado'}`);
+        if (totalWarnings > historyLines.length) {
+          historyLines.push(`... e mais ${totalWarnings - historyLines.length} advertência(s).`);
+        }
+
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: [`📋 Histórico de advertências de ${targetMention}`, `Total neste grupo: *${totalWarnings}*`, '', ...historyLines].join('\n'),
+            mentions: [targetJid],
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+      } catch (error) {
+        logger.warn('Falha ao consultar histórico de advertências no grupo.', {
+          action: 'admin_warnings_failed',
+          groupId: remoteJid,
+          senderJid,
+          targetJid,
+          error: error?.message,
+        });
+        await sendAndStore(sock, remoteJid, { text: `Não foi possível consultar as advertências. Detalhes: ${error.message}` }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+      }
+      break;
+    }
+
+    case 'clearwarn': {
+      if (!isGroupMessage) {
+        await sendAndStore(sock, remoteJid, { text: GROUP_ONLY_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+      if (!(await isUserAdmin(remoteJid, senderIdentity))) {
+        await sendAndStore(sock, remoteJid, { text: NO_PERMISSION_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+
+      const { targetJid, remainingArgs, multipleTargets } = resolveSingleTargetFromMessage(messageInfo, args);
+      if (multipleTargets || !targetJid) {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: getAdminUsageText('clearwarn', { commandPrefix, variant: 'missing_targets' }),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const rawScope = String(remainingArgs?.[0] || '')
+        .trim()
+        .toLowerCase();
+      const clearAll = rawScope === 'all';
+      const amountToClear = !rawScope || clearAll ? 1 : parsePositiveInteger(rawScope);
+
+      if (!clearAll && rawScope && !amountToClear) {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: getAdminUsageText('clearwarn', { commandPrefix, variant: 'invalid_amount' }),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      try {
+        const clearResult = await clearGroupWarnings({
+          groupId: remoteJid,
+          participantJid: targetJid,
+          clearAll,
+          limit: amountToClear || 1,
+        });
+
+        const targetMention = formatUserMentionToken(targetJid);
+        if (clearResult.removedCount <= 0) {
+          await sendAndStore(
+            sock,
+            remoteJid,
+            {
+              text: `ℹ️ ${targetMention} não possui advertências para remover neste grupo.`,
+              mentions: [targetJid],
+            },
+            { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+          );
+          break;
+        }
+
+        const removedLabel = clearAll ? `todas as advertências (${clearResult.removedCount})` : `${clearResult.removedCount} advertência(s)`;
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: `🧹 Limpeza concluída para ${targetMention}: removi *${removedLabel}*.\nAdvertências restantes neste grupo: *${clearResult.remainingCount}*.`,
+            mentions: [targetJid],
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+      } catch (error) {
+        logger.warn('Falha ao limpar advertências no grupo.', {
+          action: 'admin_clearwarn_failed',
+          groupId: remoteJid,
+          senderJid,
+          targetJid,
+          clearAll,
+          error: error?.message,
+        });
+        await sendAndStore(sock, remoteJid, { text: `Não foi possível limpar advertências. Detalhes: ${error.message}` }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+      }
+      break;
+    }
+
+    case 'warnlimit': {
+      if (!isGroupMessage) {
+        await sendAndStore(sock, remoteJid, { text: GROUP_ONLY_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+      if (!(await isUserAdmin(remoteJid, senderIdentity))) {
+        await sendAndStore(sock, remoteJid, { text: NO_PERMISSION_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+
+      const action = String(args?.[0] || '')
+        .trim()
+        .toLowerCase();
+      const groupConfig = await groupConfigStore.getGroupConfig(remoteJid);
+      const currentThreshold = clampWarnAutoBanThreshold(groupConfig?.warnAutoBanThreshold);
+
+      if (!action || action === 'status') {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: `⚖️ Limite atual de auto-ban por advertências: *${currentThreshold}*.\nUse ${commandPrefix}warnlimit <qtd> para atualizar ou ${commandPrefix}warnlimit reset para voltar ao padrão.`,
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      if (action === 'reset') {
+        await groupConfigStore.updateGroupConfig(remoteJid, { warnAutoBanThreshold: null });
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: `✅ Limite de auto-ban resetado para o padrão: *${DEFAULT_WARN_AUTO_BAN_THRESHOLD}* advertência(s).`,
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const parsedThreshold = parsePositiveInteger(action);
+      if (!parsedThreshold) {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: getAdminUsageText('warnlimit', { commandPrefix, variant: 'invalid_value' }),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const nextThreshold = Math.max(MIN_WARN_AUTO_BAN_THRESHOLD, Math.min(MAX_WARN_AUTO_BAN_THRESHOLD, parsedThreshold));
+      await groupConfigStore.updateGroupConfig(remoteJid, { warnAutoBanThreshold: nextThreshold });
+      await sendAndStore(
+        sock,
+        remoteJid,
+        {
+          text: `✅ Limite de auto-ban atualizado para *${nextThreshold}* advertência(s).`,
+        },
+        { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+      );
+      break;
+    }
+
     case 'up': {
       if (!isGroupMessage) {
         await sendAndStore(sock, remoteJid, { text: GROUP_ONLY_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
@@ -1759,6 +2376,231 @@ ${JSON.stringify(response, null, 2)}`,
       break;
     }
 
+    case 'noticiasfiltro': {
+      if (!isGroupMessage) {
+        await sendAndStore(sock, remoteJid, { text: GROUP_ONLY_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+      if (!(await isUserAdmin(remoteJid, senderIdentity))) {
+        await sendAndStore(sock, remoteJid, { text: NO_PERMISSION_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+
+      const groupConfig = await groupConfigStore.getGroupConfig(remoteJid);
+      const currentFilters = normalizeNewsFilterState(groupConfig);
+      const scope = String(args[0] || '')
+        .trim()
+        .toLowerCase();
+      const scopeToKey = {
+        source: 'sourceIds',
+        franchise: 'franchiseSlugs',
+        tag: 'entitySlugs',
+        entity: 'entitySlugs',
+      };
+
+      const buildStatusText = (filters) => ['🧪 *Filtros de notícias deste grupo*', '', `Sources: ${formatListForMessage(filters.sourceIds)}`, `Franchises: ${formatListForMessage(filters.franchiseSlugs)}`, `Tags/Entities: ${formatListForMessage(filters.entitySlugs)}`, `Somente em alta: *${filters.onlyTrending ? 'sim' : 'não'}*`, '', 'Exemplos:', `${commandPrefix}noticiasfiltro source add ann,mal`, `${commandPrefix}noticiasfiltro franchise add one-piece`, `${commandPrefix}noticiasfiltro tag add shounen`, `${commandPrefix}noticiasfiltro trending on`].join('\n');
+
+      if (!scope || scope === 'status' || scope === 'list') {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: buildStatusText(currentFilters),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      if (scope === 'reset') {
+        const resetFilters = {
+          sourceIds: [],
+          franchiseSlugs: [],
+          entitySlugs: [],
+          onlyTrending: false,
+        };
+        await groupConfigStore.updateGroupConfig(remoteJid, buildNewsFilterConfigPatch(groupConfig, resetFilters));
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: '✅ Filtros de notícias resetados com sucesso.',
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      if (scope === 'trending') {
+        const action = String(args[1] || '')
+          .trim()
+          .toLowerCase();
+        if (!action || !['on', 'off', 'status'].includes(action)) {
+          await sendAndStore(
+            sock,
+            remoteJid,
+            {
+              text: getAdminUsageText('noticiasfiltro', { commandPrefix, variant: 'trending' }),
+            },
+            { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+          );
+          break;
+        }
+
+        if (action === 'status') {
+          await sendAndStore(
+            sock,
+            remoteJid,
+            {
+              text: `📈 Filtro "somente em alta" está *${currentFilters.onlyTrending ? 'ativado' : 'desativado'}*.`,
+            },
+            { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+          );
+          break;
+        }
+
+        const nextFilters = {
+          ...currentFilters,
+          onlyTrending: action === 'on',
+        };
+        await groupConfigStore.updateGroupConfig(remoteJid, buildNewsFilterConfigPatch(groupConfig, nextFilters));
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: `✅ Filtro "somente em alta" ${nextFilters.onlyTrending ? 'ativado' : 'desativado'} com sucesso.`,
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const filterKey = scopeToKey[scope];
+      if (!filterKey) {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: getAdminUsageText('noticiasfiltro', { commandPrefix, variant: 'invalid_scope' }),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const action = String(args[1] || '')
+        .trim()
+        .toLowerCase();
+      if (!action || !['add', 'remove', 'list', 'clear'].includes(action)) {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: getAdminUsageText('noticiasfiltro', { commandPrefix, variant: 'invalid_action' }),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const scopeLabel = filterKey === 'sourceIds' ? 'sources' : filterKey === 'franchiseSlugs' ? 'franchises' : 'tags/entities';
+
+      if (action === 'list') {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: `📋 Filtro de notícias (${scopeLabel}): ${formatListForMessage(currentFilters[filterKey])}`,
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      if (action === 'clear') {
+        const nextFilters = {
+          ...currentFilters,
+          [filterKey]: [],
+        };
+        await groupConfigStore.updateGroupConfig(remoteJid, buildNewsFilterConfigPatch(groupConfig, nextFilters));
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: `✅ Filtro de notícias (${scopeLabel}) limpo com sucesso.`,
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const values = parseFilterValues(args.slice(2));
+      if (values.length === 0) {
+        await sendAndStore(
+          sock,
+          remoteJid,
+          {
+            text: getAdminUsageText('noticiasfiltro', { commandPrefix, variant: 'missing_values' }),
+          },
+          { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+        );
+        break;
+      }
+
+      const currentSet = new Set(currentFilters[filterKey]);
+      if (action === 'add') {
+        values.forEach((value) => currentSet.add(value));
+      } else {
+        values.forEach((value) => currentSet.delete(value));
+      }
+
+      const nextFilters = {
+        ...currentFilters,
+        [filterKey]: Array.from(currentSet).sort((left, right) => left.localeCompare(right)),
+      };
+      await groupConfigStore.updateGroupConfig(remoteJid, buildNewsFilterConfigPatch(groupConfig, nextFilters));
+      await sendAndStore(
+        sock,
+        remoteJid,
+        {
+          text: `✅ Filtro de notícias (${scopeLabel}) atualizado: ${formatListForMessage(nextFilters[filterKey])}`,
+        },
+        { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+      );
+      break;
+    }
+
+    case 'grupoaudit': {
+      if (!isGroupMessage) {
+        await sendAndStore(sock, remoteJid, { text: GROUP_ONLY_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+      if (!(await isUserAdmin(remoteJid, senderIdentity))) {
+        await sendAndStore(sock, remoteJid, { text: NO_PERMISSION_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+        break;
+      }
+
+      const groupConfig = await groupConfigStore.getGroupConfig(remoteJid);
+      const stickerState = resolveStickerFocusState(groupConfig);
+      const newsStatus = await getNewsStatusForGroup(remoteJid);
+      const auditText = buildGroupAuditText({
+        config: groupConfig,
+        stickerState,
+        newsStatus,
+        commandPrefix,
+      });
+
+      await sendAndStore(
+        sock,
+        remoteJid,
+        {
+          text: auditText,
+        },
+        { quoted: messageInfo, ephemeralExpiration: expirationMessage },
+      );
+      break;
+    }
+
     case 'noticias': {
       if (!isGroupMessage) {
         await sendAndStore(sock, remoteJid, { text: GROUP_ONLY_COMMAND_MESSAGE }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });