@omnizap-system/omnizap 2.5.12

package/app/controllers/messageController.js

@@ -0,0 +1,7 @@
+import { handleMessagesThroughPipeline } from './messageProcessingPipeline.js';
+
+/**
+ * Facade do controller de mensagens.
+ * Mantem assinatura/compatibilidade enquanto delega ao pipeline modular.
+ */
+export const handleMessages = async (update, sock) => handleMessagesThroughPipeline(update, sock);

package/app/controllers/messagePipeline/commandMiddleware.js

@@ -0,0 +1,146 @@
+export const createCommandMiddleware = ({ isAdminCommand, isKnownNonAdminCommand, isDuplicateCommandExecution, markCommandExecution, MESSAGE_COMMAND_DEDUPE_TTL_MS, stopMessagePipeline, WHATSAPP_COMMAND_REQUIRES_GOOGLE_LOGIN, resolveCanonicalSenderJidForContext, ensureUserHasGoogleWebLoginForCommand, SITE_LOGIN_URL, COMMAND_REACT_EMOJI, sendAndStore, executeMessageCommandRoute, runCommand, sendReply, registerGlobalHelpCommandExecution, logger, normalizeAnalysisErrorCode, resolveSenderAdminForContext, isUserAdmin, buildCommandErrorHelpText, mergeAnalysisMetadata }) => {
+  return async (ctx) => {
+    if (!ctx.isCommandMessage) return null;
+
+    const commandBody = ctx.extractedText.substring(ctx.commandPrefix.length);
+    const match = commandBody.match(/^(\S+)([\s\S]*)$/);
+    const command = match ? match[1].toLowerCase() : '';
+    const rawArgs = match && match[2] !== undefined ? match[2].trim() : '';
+    const args = rawArgs ? rawArgs.split(/\s+/) : [];
+    const text = match && match[2] !== undefined ? match[2] : '';
+    const isAdminCommandRoute = isAdminCommand(command);
+    const isKnownCommand = isKnownNonAdminCommand(command) || isAdminCommandRoute;
+
+    ctx.analysisPayload.commandName = command || null;
+    ctx.analysisPayload.commandArgsCount = args.length;
+    ctx.analysisPayload.commandKnown = isKnownCommand;
+
+    if (isDuplicateCommandExecution(ctx.remoteJid, ctx.key?.id)) {
+      return stopMessagePipeline(ctx, 'duplicate_command_ignored', {
+        dedupe_ttl_ms: MESSAGE_COMMAND_DEDUPE_TTL_MS,
+      });
+    }
+    markCommandExecution(ctx.remoteJid, ctx.key?.id);
+
+    if (!ctx.isMessageFromBot && WHATSAPP_COMMAND_REQUIRES_GOOGLE_LOGIN) {
+      const canonicalSenderJid = await resolveCanonicalSenderJidForContext(ctx);
+      const authCheck = await ensureUserHasGoogleWebLoginForCommand({
+        sock: ctx.sock,
+        messageInfo: ctx.messageInfo,
+        senderJid: ctx.senderJid,
+        remoteJid: ctx.remoteJid,
+        expirationMessage: ctx.expirationMessage,
+        commandPrefix: ctx.commandPrefix,
+        canonicalUserId: canonicalSenderJid,
+      });
+
+      if (!authCheck.allowed) {
+        return stopMessagePipeline(ctx, 'auth_required', {
+          auth_required_for_command: command || null,
+          auth_login_url: authCheck.loginUrl || SITE_LOGIN_URL,
+        });
+      }
+    }
+
+    if (COMMAND_REACT_EMOJI) {
+      try {
+        await sendAndStore(ctx.sock, ctx.remoteJid, {
+          react: {
+            text: COMMAND_REACT_EMOJI,
+            key: ctx.key,
+          },
+        });
+      } catch (error) {
+        logger.warn('Falha ao enviar reação de comando:', error?.message);
+      }
+    }
+
+    const execution = await executeMessageCommandRoute({
+      command,
+      args,
+      text,
+      isAdminCommandRoute,
+      sock: ctx.sock,
+      remoteJid: ctx.remoteJid,
+      messageInfo: ctx.messageInfo,
+      expirationMessage: ctx.expirationMessage,
+      senderJid: ctx.senderJid,
+      senderName: ctx.senderName,
+      senderIdentity: ctx.senderIdentity,
+      botJid: ctx.botJid,
+      isGroupMessage: ctx.isGroupMessage,
+      commandPrefix: ctx.commandPrefix,
+      runCommand,
+      sendReply,
+    });
+    const commandResult = execution?.commandResult || { ok: false };
+    const commandRoute = execution?.commandRoute || 'unknown';
+    if (commandRoute === 'unknown') {
+      ctx.analysisPayload.processingResult = 'unknown_command';
+    }
+
+    mergeAnalysisMetadata(ctx.analysisPayload, {
+      command_route: commandRoute,
+    });
+
+    if (ctx.analysisPayload.processingResult === 'processed') {
+      ctx.analysisPayload.processingResult = commandResult.ok ? 'command_executed' : 'command_error';
+    }
+
+    if (commandResult.ok && commandRoute !== 'unknown') {
+      try {
+        await registerGlobalHelpCommandExecution({
+          chatId: ctx.remoteJid,
+          userId: ctx.senderJid,
+          isGroupMessage: ctx.isGroupMessage,
+          executedCommand: command,
+        });
+      } catch (error) {
+        logger.warn('Falha ao registrar feedback de sugestao global.', {
+          action: 'global_help_feedback_register_failed',
+          command,
+          commandRoute,
+          remoteJid: ctx.remoteJid,
+          senderJid: ctx.senderJid,
+          error: error?.message,
+        });
+      }
+    }
+
+    if (!commandResult.ok) {
+      ctx.analysisPayload.errorCode = normalizeAnalysisErrorCode(commandResult.error);
+      let senderIsAdminForHelp = false;
+      if (ctx.isGroupMessage) {
+        try {
+          senderIsAdminForHelp = typeof resolveSenderAdminForContext === 'function' ? await resolveSenderAdminForContext(ctx, { mode: 'identity' }) : await isUserAdmin(ctx.remoteJid, ctx.senderIdentity);
+        } catch (error) {
+          logger.warn('Falha ao resolver permissao de admin para ajuda de comando.', {
+            action: 'command_error_help_admin_check_failed',
+            command,
+            remoteJid: ctx.remoteJid,
+            senderJid: ctx.senderJid,
+            error: error?.message,
+          });
+        }
+      }
+
+      const commandErrorHelpText = await buildCommandErrorHelpText({
+        command,
+        commandRoute,
+        commandPrefix: ctx.commandPrefix,
+        isGroupMessage: ctx.isGroupMessage,
+        isSenderAdmin: senderIsAdminForHelp,
+      });
+
+      const fallbackErrorText = commandErrorHelpText ? `❌ Houve um erro ao processar *${ctx.commandPrefix}${command}*.\n\n${commandErrorHelpText}` : `❌ Houve um erro ao processar *${ctx.commandPrefix}${command}*.\n\nTente novamente ou use *${ctx.commandPrefix}menu* para validar o formato de uso.`;
+
+      await runCommand('command-error-help', () =>
+        sendReply(ctx.sock, ctx.remoteJid, ctx.messageInfo, ctx.expirationMessage, {
+          text: fallbackErrorText,
+        }),
+      );
+    }
+
+    return null;
+  };
+};

package/app/controllers/messagePipeline/conversationMiddleware.js

@@ -0,0 +1,183 @@
+export const createConversationMiddleware = ({ logger, resolveSenderAdminForContext, resolveSenderOwnerForContext, resolveHasGoogleLoginForContext, isUserAdmin, isAdminSenderAsync, resolveCanonicalSenderJidForContext, isWhatsAppUserLinkedToGoogleWebAccount, WHATSAPP_COMMAND_REQUIRES_GOOGLE_LOGIN, ensureUserHasGoogleWebLoginForCommand, executeMessageCommandRoute, isAdminCommand, runCommand, sendReply, routeConversationMessage, stopMessagePipeline }) => {
+  const resolveToolSecurityContextForConversation = async (ctx) => {
+    if (ctx.memo.toolSecurityContext) return ctx.memo.toolSecurityContext;
+
+    let isSenderAdmin = false;
+    if (ctx.isGroupMessage) {
+      try {
+        isSenderAdmin = typeof resolveSenderAdminForContext === 'function' ? await resolveSenderAdminForContext(ctx, { mode: 'identity' }) : await isUserAdmin(ctx.remoteJid, ctx.senderIdentity);
+      } catch (error) {
+        logger.warn('Falha ao resolver permissao admin para tool execution.', {
+          action: 'tool_security_admin_check_failed',
+          remoteJid: ctx.remoteJid,
+          senderJid: ctx.senderJid,
+          error: error?.message,
+        });
+      }
+    }
+
+    let isSenderOwner = false;
+    try {
+      isSenderOwner = typeof resolveSenderOwnerForContext === 'function' ? await resolveSenderOwnerForContext(ctx) : await isAdminSenderAsync(ctx.senderIdentity);
+    } catch (error) {
+      logger.warn('Falha ao resolver admin principal para tool execution.', {
+        action: 'tool_security_owner_check_failed',
+        remoteJid: ctx.remoteJid,
+        senderJid: ctx.senderJid,
+        error: error?.message,
+      });
+    }
+
+    let hasGoogleLogin;
+    if (!ctx.isMessageFromBot && WHATSAPP_COMMAND_REQUIRES_GOOGLE_LOGIN) {
+      try {
+        hasGoogleLogin = typeof resolveHasGoogleLoginForContext === 'function' ? await resolveHasGoogleLoginForContext(ctx) : undefined;
+        if (hasGoogleLogin === undefined) {
+          const canonicalSenderJid = await resolveCanonicalSenderJidForContext(ctx);
+          if (canonicalSenderJid) {
+            hasGoogleLogin = await isWhatsAppUserLinkedToGoogleWebAccount({
+              ownerJid: canonicalSenderJid,
+            });
+          }
+        }
+      } catch (error) {
+        logger.warn('Falha ao resolver estado de login para tool execution.', {
+          action: 'tool_security_google_login_check_failed',
+          remoteJid: ctx.remoteJid,
+          senderJid: ctx.senderJid,
+          error: error?.message,
+        });
+      }
+    }
+
+    ctx.memo.toolSecurityContext = {
+      isGroupMessage: ctx.isGroupMessage,
+      isSenderAdmin,
+      isSenderOwner,
+      hasGoogleLogin,
+    };
+    return ctx.memo.toolSecurityContext;
+  };
+
+  const executeToolCommandFromConversation = async (ctx, { commandName, args = [], text = '' } = {}) => {
+    const normalizedCommand = String(commandName || '')
+      .trim()
+      .toLowerCase();
+    if (!normalizedCommand) {
+      return {
+        ok: false,
+        alreadyResponded: false,
+        text: 'Comando invalido na tool call.',
+      };
+    }
+
+    if (!ctx.isMessageFromBot && WHATSAPP_COMMAND_REQUIRES_GOOGLE_LOGIN) {
+      let knownHasGoogleLogin;
+      if (typeof ctx.memo.toolSecurityContext?.hasGoogleLogin === 'boolean') {
+        knownHasGoogleLogin = ctx.memo.toolSecurityContext.hasGoogleLogin;
+      } else if (typeof resolveHasGoogleLoginForContext === 'function') {
+        try {
+          knownHasGoogleLogin = await resolveHasGoogleLoginForContext(ctx);
+        } catch {
+          knownHasGoogleLogin = undefined;
+        }
+      }
+
+      const authCheck = await ensureUserHasGoogleWebLoginForCommand({
+        sock: ctx.sock,
+        messageInfo: ctx.messageInfo,
+        senderJid: ctx.senderJid,
+        remoteJid: ctx.remoteJid,
+        expirationMessage: ctx.expirationMessage,
+        commandPrefix: ctx.commandPrefix,
+        knownHasGoogleLogin,
+      });
+      if (!authCheck.allowed) {
+        return {
+          ok: false,
+          alreadyResponded: true,
+          text: '',
+          errorCode: 'auth_required',
+        };
+      }
+    }
+
+    const commandExecution = await executeMessageCommandRoute({
+      command: normalizedCommand,
+      args: Array.isArray(args) ? args : [],
+      text: String(text || ''),
+      isAdminCommandRoute: isAdminCommand(normalizedCommand),
+      sock: ctx.sock,
+      remoteJid: ctx.remoteJid,
+      messageInfo: ctx.messageInfo,
+      expirationMessage: ctx.expirationMessage,
+      senderJid: ctx.senderJid,
+      senderName: ctx.senderName,
+      senderIdentity: ctx.senderIdentity,
+      botJid: ctx.botJid,
+      isGroupMessage: ctx.isGroupMessage,
+      commandPrefix: ctx.commandPrefix,
+      runCommand,
+      sendReply,
+    });
+
+    const commandRoute = commandExecution?.commandRoute || 'unknown';
+    const commandResult = commandExecution?.commandResult || { ok: false };
+    return {
+      ok: commandResult.ok && commandRoute !== 'unknown',
+      commandRoute,
+      alreadyResponded: commandResult.ok || commandRoute === 'unknown',
+      text: '',
+      error: commandResult?.error || null,
+    };
+  };
+
+  return async (ctx) => {
+    if (ctx.isCommandMessage || ctx.isMessageFromBot || !ctx.isNotifyUpsert) return null;
+
+    try {
+      const conversationResult = await routeConversationMessage({
+        messageInfo: ctx.messageInfo,
+        extractedText: ctx.extractedText,
+        isCommandMessage: ctx.isCommandMessage,
+        mediaEntries: ctx.mediaEntries,
+        isGroupMessage: ctx.isGroupMessage,
+        remoteJid: ctx.remoteJid,
+        senderJid: ctx.senderJid,
+        botJid: ctx.botJid,
+        botJidCandidates: ctx.botJidCandidates,
+        commandPrefix: ctx.commandPrefix,
+        toolCommandExecutor: (payload) => executeToolCommandFromConversation(ctx, payload),
+        resolveToolSecurityContext: () => resolveToolSecurityContextForConversation(ctx),
+      });
+
+      if (!conversationResult?.handled) return null;
+
+      if (conversationResult?.text) {
+        await sendReply(ctx.sock, ctx.remoteJid, ctx.messageInfo, ctx.expirationMessage, {
+          text: conversationResult.text,
+        });
+      }
+
+      return stopMessagePipeline(ctx, 'conversation_reply', {
+        conversation_router: true,
+        conversation_reason: conversationResult.reason || null,
+        conversation_trigger_kind: conversationResult?.metadata?.trigger_kind || null,
+        conversation_intent_type: conversationResult?.metadata?.intent_type || null,
+        conversation_module_key: conversationResult?.metadata?.module_key || null,
+        conversation_command_name: conversationResult?.metadata?.command_name || null,
+        conversation_suppress_reply: Boolean(conversationResult?.metadata?.suppress_reply),
+      });
+    } catch (error) {
+      logger.warn('Falha ao processar rota conversacional global.', {
+        action: 'conversation_router_failed',
+        remoteJid: ctx.remoteJid,
+        senderJid: ctx.senderJid,
+        isGroupMessage: ctx.isGroupMessage,
+        error: error?.message,
+      });
+    }
+
+    return null;
+  };
+};