@omnizap-system/omnizap 2.6.1 → 2.6.2

package/app/services/ai/geminiService.test.js

@@ -2,8 +2,8 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { createGeminiTextService } from './geminiService.js';
 
-test('createGeminiTextService retorna null quando GEMINI_API_KEY nao existe', () => {
-  const service = createGeminiTextService({ apiKey: '' });
+test('createGeminiTextService retorna null no modo api_key quando GEMINI_API_KEY nao existe', () => {
+  const service = createGeminiTextService({ authMode: 'api_key', apiKey: '' });
   assert.equal(service, null);
 });
 
@@ -85,3 +85,60 @@ test('createGeminiTextService propaga erro detalhado da API', async (t) => {
     /Modelo invalido/,
   );
 });
+
+test('createGeminiTextService usa Gemini CLI quando authMode=cli', async () => {
+  const calls = [];
+  const service = createGeminiTextService({
+    authMode: 'cli',
+    cliCommand: 'gemini',
+    defaultModel: 'gemini-2.5-flash',
+    isCliAvailableImpl: () => true,
+    execFileAsyncImpl: async (file, args, options) => {
+      calls.push({ file, args, options });
+      return {
+        stdout: 'OK_GEMINI_CLI\n',
+        stderr: 'Loaded cached credentials.',
+      };
+    },
+  });
+
+  assert.ok(service);
+  assert.equal(service.transport, 'cli');
+
+  const response = await service.generateText({
+    instructions: 'Responda curto.',
+    userPrompt: 'Diga OK.',
+    model: 'gemini-2.5-flash',
+  });
+
+  assert.equal(response.model, 'gemini-2.5-flash');
+  assert.equal(response.text, 'OK_GEMINI_CLI');
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].file, 'gemini');
+  assert.ok(calls[0].args.includes('-m'));
+  assert.ok(calls[0].args.includes('gemini-2.5-flash'));
+  assert.ok(calls[0].args.includes('-p'));
+  assert.ok(calls[0].args.includes('--output-format'));
+});
+
+test('createGeminiTextService propaga erro do Gemini CLI', async () => {
+  const service = createGeminiTextService({
+    authMode: 'cli',
+    cliCommand: 'gemini',
+    defaultModel: 'gemini-2.5-flash',
+    isCliAvailableImpl: () => true,
+    execFileAsyncImpl: async () => {
+      const error = new Error('Command failed');
+      error.stderr = 'ModelNotFoundError: Requested entity was not found.';
+      throw error;
+    },
+  });
+
+  await assert.rejects(
+    () =>
+      service.generateText({
+        userPrompt: 'teste',
+      }),
+    /ModelNotFoundError/,
+  );
+});

package/app/services/ai/moduleAiHelpCoreService.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import OpenAI from 'openai';
 import { getAiHelpCachedResponse, upsertAiHelpCachedResponse } from './aiHelpResponseCacheRepository.js';
-import { createGeminiTextService, DEFAULT_GEMINI_MODEL } from './geminiService.js';
+import { createGeminiTextService, DEFAULT_GEMINI_MODEL, isGeminiAuthReady } from './geminiService.js';
 
 const DEFAULT_FAQ_INTERVAL_MS = 6 * 60 * 60 * 1000;
 const DEFAULT_MAX_RESPONSE_CHARS = 3400;
@@ -169,6 +169,16 @@ const normalizeLlmProvider = (value, fallback = 'gemini') => {
   return fallback;
 };
 
+const normalizeGeminiAuthMode = (value, fallback = 'cli') => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  if (normalized === 'api_key') return 'api_key';
+  if (normalized === 'cli') return 'cli';
+  if (normalized === 'auto') return 'auto';
+  return fallback;
+};
+
 const looksLikeGeminiModel = (value) =>
   String(value || '')
     .trim()
@@ -241,7 +251,13 @@ export const createModuleAiHelpService = ({ moduleKey, moduleLabel = 'modulo', e
     const cachePathValue = String(faq.cache_file || '').trim();
     const cachePath = cachePathValue ? path.resolve(process.cwd(), cachePathValue) : path.join(process.cwd(), 'data', 'cache', `${moduleKey}-ai-faq-cache.json`);
 
-    const provider = normalizeLlmProvider(envValue('PROVIDER') || llm.provider || process.env.AI_HELP_LLM_PROVIDER, process.env.GEMINI_API_KEY ? 'gemini' : 'openai');
+    const geminiAuthMode = normalizeGeminiAuthMode(envValue('GEMINI_AUTH_MODE') || llm.gemini_auth_mode || process.env.GEMINI_AUTH_MODE, 'cli');
+    const hasGeminiAuthHint = isGeminiAuthReady({
+      authMode: geminiAuthMode,
+      apiKey: process.env.GEMINI_API_KEY,
+      cliCommand: process.env.GEMINI_CLI_COMMAND || 'gemini',
+    });
+    const provider = normalizeLlmProvider(envValue('PROVIDER') || llm.provider || process.env.AI_HELP_LLM_PROVIDER, hasGeminiAuthHint ? 'gemini' : 'openai');
     const defaultModelByProvider = provider === 'gemini' ? process.env.GEMINI_MODEL || DEFAULT_GEMINI_MODEL : process.env.OPENAI_MODEL || DEFAULT_OPENAI_MODEL;
     const rawModel = String(envValue('MODEL') || llm.model || defaultModelByProvider).trim() || defaultModelByProvider;
     const modelFromEnv = String(envValue('MODEL') || '').trim();
@@ -271,6 +287,7 @@ export const createModuleAiHelpService = ({ moduleKey, moduleLabel = 'modulo', e
             .trim()
             .toLowerCase() !== 'false',
         provider,
+        geminiAuthMode,
         model: resolvedModel,
         maxResponseChars: Math.max(400, toPositiveInt(envValue('MAX_RESPONSE_CHARS') || llm.max_response_chars, DEFAULT_MAX_RESPONSE_CHARS, 400)),
         maxAgentContextChars: Math.max(2_000, toPositiveInt(envValue('MAX_AGENT_CONTEXT_CHARS') || llm.max_agent_context_chars, DEFAULT_MAX_AGENT_CONTEXT_CHARS, 2_000)),
@@ -286,6 +303,7 @@ export const createModuleAiHelpService = ({ moduleKey, moduleLabel = 'modulo', e
   let faqGenerationPromise = null;
   let cachedOpenAIClient = null;
   let cachedGeminiService = null;
+  let cachedGeminiServiceKey = '';
 
   const createEmptyCache = () => ({
     version: FAQ_CACHE_VERSION,
@@ -441,7 +459,14 @@ export const createModuleAiHelpService = ({ moduleKey, moduleLabel = 'modulo', e
       .join('\n');
   };
 
-  const isGeminiReady = () => Boolean(String(process.env.GEMINI_API_KEY || '').trim());
+  const isGeminiReady = () => {
+    const config = getAiHelpConfig();
+    return isGeminiAuthReady({
+      authMode: config.llm.geminiAuthMode,
+      apiKey: process.env.GEMINI_API_KEY,
+      cliCommand: process.env.GEMINI_CLI_COMMAND || 'gemini',
+    });
+  };
   const isOpenAIReady = () => Boolean(String(process.env.OPENAI_API_KEY || '').trim());
   const isProviderReady = (provider) => (provider === 'gemini' ? isGeminiReady() : isOpenAIReady());
 
@@ -453,12 +478,16 @@ export const createModuleAiHelpService = ({ moduleKey, moduleLabel = 'modulo', e
   const getGeminiService = () => {
     if (!isGeminiReady()) return null;
     const config = getAiHelpConfig();
-    if (!cachedGeminiService) {
+    const currentServiceKey = `${config.llm.model}|${config.llm.timeoutMs}|${config.llm.geminiAuthMode}|${process.env.GEMINI_CLI_COMMAND || 'gemini'}|${Boolean(String(process.env.GEMINI_API_KEY || '').trim())}`;
+    if (!cachedGeminiService || cachedGeminiServiceKey !== currentServiceKey) {
       cachedGeminiService = createGeminiTextService({
         apiKey: process.env.GEMINI_API_KEY,
         defaultModel: config.llm.model || process.env.GEMINI_MODEL || DEFAULT_GEMINI_MODEL,
         timeoutMs: config.llm.timeoutMs,
+        authMode: config.llm.geminiAuthMode,
+        cliCommand: process.env.GEMINI_CLI_COMMAND || 'gemini',
       });
+      cachedGeminiServiceKey = currentServiceKey;
     }
     return cachedGeminiService;
   };

package/app/services/group/groupMetadataService.js

@@ -2,7 +2,7 @@ import logger from '#logger';
 import { findById, upsert } from '../../../database/index.js';
 import { extractUserIdInfo, resolveUserIdCached, isLidUserId, isWhatsAppUserId } from '../../config/index.js';
 
-const GROUP_METADATA_FIELDS = ['id', 'subject', 'description', 'owner_jid', 'creation', 'participants'];
+const GROUP_METADATA_FIELDS = ['id', 'subject', 'description', 'owner_jid', 'creation', 'participants', 'linked_parent_jid', 'is_community', 'is_community_announce', 'member_add_mode', 'join_approval_mode', 'addressing_mode'];
 
 const PARTICIPANT_ACTIONS = new Set(['add', 'remove', 'promote', 'demote', 'modify']);
 
@@ -285,6 +285,17 @@ export const buildGroupMetadataFromUpdate = (event, existing) => {
   const currentParticipants = parseParticipantsFromDb(existing?.participants);
   const participants = event.participants || currentParticipants;
   const normalizedParticipants = normalizeParticipantsList(participants);
+  const resolveExistingValue = (snakeKey, camelKey) => existing?.[snakeKey] ?? existing?.[camelKey];
+  const resolveBoolean = (eventValue, snakeKey, camelKey) => {
+    if (eventValue !== undefined) return Boolean(eventValue);
+    const existingValue = resolveExistingValue(snakeKey, camelKey);
+    return existingValue === undefined || existingValue === null ? null : Boolean(existingValue);
+  };
+
+  const linkedParentRaw = event.linkedParent ?? resolveExistingValue('linked_parent_jid', 'linkedParent');
+  const linkedParent = typeof linkedParentRaw === 'string' ? linkedParentRaw.trim() || null : linkedParentRaw || null;
+  const addressingModeRaw = event.addressingMode ?? resolveExistingValue('addressing_mode', 'addressingMode');
+  const addressingMode = typeof addressingModeRaw === 'string' ? addressingModeRaw.trim() || null : addressingModeRaw || null;
 
   return {
     id: event.id,
@@ -293,6 +304,12 @@ export const buildGroupMetadataFromUpdate = (event, existing) => {
     owner_jid: event.owner ?? existing?.owner_jid,
     creation: event.creation ?? existing?.creation,
     participants: normalizedParticipants,
+    linked_parent_jid: linkedParent,
+    is_community: resolveBoolean(event.isCommunity, 'is_community', 'isCommunity'),
+    is_community_announce: resolveBoolean(event.isCommunityAnnounce, 'is_community_announce', 'isCommunityAnnounce'),
+    member_add_mode: resolveBoolean(event.memberAddMode, 'member_add_mode', 'memberAddMode'),
+    join_approval_mode: resolveBoolean(event.joinApprovalMode, 'join_approval_mode', 'joinApprovalMode'),
+    addressing_mode: addressingMode,
   };
 };
 
@@ -308,4 +325,10 @@ export const buildGroupMetadataFromGroup = (group) => ({
   owner_jid: group.owner,
   creation: group.creation,
   participants: normalizeParticipantsList(group.participants || []),
+  linked_parent_jid: typeof group.linkedParent === 'string' ? group.linkedParent.trim() || null : group.linkedParent || null,
+  is_community: group.isCommunity === undefined ? null : Boolean(group.isCommunity),
+  is_community_announce: group.isCommunityAnnounce === undefined ? null : Boolean(group.isCommunityAnnounce),
+  member_add_mode: group.memberAddMode === undefined ? null : Boolean(group.memberAddMode),
+  join_approval_mode: group.joinApprovalMode === undefined ? null : Boolean(group.joinApprovalMode),
+  addressing_mode: typeof group.addressingMode === 'string' ? group.addressingMode.trim() || null : group.addressingMode || null,
 });

package/app/services/infra/dbWriteQueue.js

@@ -105,7 +105,7 @@ const INVALID_SURROGATE_REGEX = /surrogate pair/i;
 const messageQueue = [];
 
 /**
- * Conjunto de IDs de mensagens que já estão enfileiradas, para evitar duplicação.
+ * Conjunto de IDs de mensagens já enfileiradas no formato `${session_id}:${message_id}`.
  * @type {Set<string>}
  */
 const messagePendingIds = new Set();
@@ -132,7 +132,7 @@ const chatCache = new Map();
 
 /**
  * Fila em memória com eventos do Baileys pendentes de persistência.
- * @type {Array<{event_name:string, socket_generation:(number|null), chat_id:(string|null), message_id:(string|null), participant_id:(string|null), payload_summary:(string|null), event_timestamp:Date}>}
+ * @type {Array<{session_id:string, event_name:string, socket_generation:(number|null), chat_id:(string|null), message_id:(string|null), participant_id:(string|null), payload_summary:(string|null), event_timestamp:Date}>}
  */
 const baileysEventQueue = [];
 
@@ -251,8 +251,8 @@ const isInvalidJsonPayloadError = (error) => {
  * - content: remove surrogate inválido
  * - raw_message: serializa JSON seguro para coluna JSON
  *
- * @param {{message_id:string, chat_id:string, sender_id:string, canonical_sender_id?:(string|null), content:(string|null), raw_message:(Object|string|null), timestamp:(number|string|Date)}} messageData
- * @returns {{message_id:string, chat_id:string, sender_id:(string|null), canonical_sender_id:(string|null), content:(string|null), raw_message:(string|null), timestamp:(number|string|Date)}}
+ * @param {{session_id?:(string|null), message_id:string, chat_id:string, sender_id:string, canonical_sender_id?:(string|null), content:(string|null), raw_message:(Object|string|null), timestamp:(number|string|Date), allow_group_write?:(boolean)}} messageData
+ * @returns {{session_id:string, message_id:string, chat_id:(string|null), sender_id:(string|null), canonical_sender_id:(string|null), content:(string|null), raw_message:(string|null), timestamp:(number|string|Date)}}
  */
 const normalizeUserIdForColumn = (value, maxLength = 255) => {
   if (value === null || value === undefined) return null;
@@ -277,8 +277,13 @@ const resolveCanonicalSenderIdForMessage = (messageData) => {
 
 const normalizeMessageForQueue = (messageData) => {
   const senderId = normalizeUserIdForColumn(messageData?.sender_id, 255);
+  const messageId = normalizeTextForColumn(messageData?.message_id, 255);
+  const chatId = normalizeTextForColumn(messageData?.chat_id, 255);
   return {
     ...messageData,
+    session_id: normalizeSessionIdForColumn(messageData?.session_id || messageData?.sessionId),
+    message_id: messageId,
+    chat_id: chatId,
     sender_id: senderId,
     canonical_sender_id: resolveCanonicalSenderIdForMessage({
       ...messageData,
@@ -302,7 +307,25 @@ const normalizeTimestampForColumn = (value) => {
   return __timeNow();
 };
 
+const normalizeSessionIdForColumn = (value) => {
+  const normalized = normalizeTextForColumn(value, 64);
+  return normalized || 'default';
+};
+
+const isGroupChatId = (chatId) => {
+  const normalized = String(chatId || '').trim();
+  return normalized.endsWith('@g.us');
+};
+
+const buildMessagePendingKey = (sessionId, messageId) => {
+  const safeSessionId = normalizeSessionIdForColumn(sessionId);
+  const safeMessageId = normalizeTextForColumn(messageId, 255);
+  if (!safeMessageId) return null;
+  return `${safeSessionId}:${safeMessageId}`;
+};
+
 const normalizeBaileysEventForQueue = (eventData) => ({
+  session_id: normalizeSessionIdForColumn(eventData?.session_id || eventData?.sessionId),
   event_name: normalizeTextForColumn(eventData?.event_name, 64),
   socket_generation: Number.isFinite(Number(eventData?.socket_generation)) ? Math.max(0, Math.floor(Number(eventData.socket_generation))) : null,
   chat_id: normalizeTextForColumn(eventData?.chat_id, 255),
@@ -313,14 +336,14 @@ const normalizeBaileysEventForQueue = (eventData) => ({
 });
 
 const insertBaileysEventBatch = async (batch) => {
-  const placeholders = buildPlaceholders(batch.length, 7);
+  const placeholders = buildPlaceholders(batch.length, 8);
   const params = [];
   for (const entry of batch) {
-    params.push(entry.event_name, entry.socket_generation, entry.chat_id, entry.message_id, entry.participant_id, entry.payload_summary, entry.event_timestamp);
+    params.push(entry.session_id, entry.event_name, entry.socket_generation, entry.chat_id, entry.message_id, entry.participant_id, entry.payload_summary, entry.event_timestamp);
   }
 
   const sql = `INSERT INTO ${TABLES.BAILEYS_EVENT_JOURNAL}
-      (event_name, socket_generation, chat_id, message_id, participant_id, payload_summary, event_timestamp)
+      (session_id, event_name, socket_generation, chat_id, message_id, participant_id, payload_summary, event_timestamp)
       VALUES ${placeholders}`;
 
   await executeQuery(sql, params);
@@ -329,18 +352,18 @@ const insertBaileysEventBatch = async (batch) => {
 /**
  * Executa INSERT IGNORE de um batch de mensagens.
  *
- * @param {Array<{message_id:string, chat_id:string, sender_id:(string|null), canonical_sender_id:(string|null), content:(string|null), raw_message:(string|null), timestamp:(number|string|Date)}>} batch
+ * @param {Array<{session_id:string, message_id:string, chat_id:string, sender_id:(string|null), canonical_sender_id:(string|null), content:(string|null), raw_message:(string|null), timestamp:(number|string|Date)}>} batch
  * @returns {Promise<void>}
  */
 const insertMessageBatch = async (batch) => {
-  const placeholders = buildPlaceholders(batch.length, 7);
+  const placeholders = buildPlaceholders(batch.length, 8);
   const params = [];
   for (const message of batch) {
-    params.push(message.message_id, message.chat_id, message.sender_id, message.canonical_sender_id, message.content, message.raw_message, message.timestamp);
+    params.push(message.session_id, message.message_id, message.chat_id, message.sender_id, message.canonical_sender_id, message.content, message.raw_message, message.timestamp);
   }
 
   const sql = `INSERT IGNORE INTO ${TABLES.MESSAGES}
-      (message_id, chat_id, sender_id, canonical_sender_id, content, raw_message, timestamp)
+      (session_id, message_id, chat_id, sender_id, canonical_sender_id, content, raw_message, timestamp)
       VALUES ${placeholders}`;
 
   await executeQuery(sql, params);
@@ -424,12 +447,13 @@ const refreshMessageActivityDailyForBatch = async (batch) => {
 /**
  * Remove IDs de mensagens do set de pendentes.
  *
- * @param {Array<{message_id:string}>} batch
+ * @param {Array<{session_id:string, message_id:string}>} batch
  * @returns {void}
  */
 const clearPendingMessageIds = (batch) => {
   for (const message of batch) {
-    messagePendingIds.delete(message.message_id);
+    const key = buildMessagePendingKey(message?.session_id, message?.message_id);
+    if (key) messagePendingIds.delete(key);
   }
 };
 
@@ -438,7 +462,7 @@ const clearPendingMessageIds = (batch) => {
  * - Mensagem inválida é descartada para não travar a fila inteira.
  * - Em erro transitório, re-enfileira o restante e interrompe.
  *
- * @param {Array<{message_id:string, chat_id:string, sender_id:(string|null), canonical_sender_id:(string|null), content:(string|null), raw_message:(string|null), timestamp:(number|string|Date)}>} batch
+ * @param {Array<{session_id:string, message_id:string, chat_id:string, sender_id:(string|null), canonical_sender_id:(string|null), content:(string|null), raw_message:(string|null), timestamp:(number|string|Date)}>} batch
  * @returns {Promise<void>}
  */
 const salvageJsonErrorBatch = async (batch) => {
@@ -679,26 +703,32 @@ const baileysEventFlushRunner = createFlushRunner({
 
 /**
  * Enfileira uma mensagem para INSERT no banco (INSERT IGNORE).
- * - Evita duplicar message_id usando um Set.
+ * - Evita duplicar por `${session_id}:${message_id}` usando um Set.
  * - Força flush se a fila estiver muito grande.
  * - Agenda flush quando atinge o tamanho de batch.
  *
- * @param {{message_id:string, chat_id:string, sender_id:string, canonical_sender_id?:(string|null), content:(string|null), raw_message:(Object|string|null), timestamp:(number|string)}} messageData
+ * @param {{session_id?:(string|null), message_id:string, chat_id:string, sender_id:string, canonical_sender_id?:(string|null), content:(string|null), raw_message:(Object|string|null), timestamp:(number|string), allow_group_write?:(boolean)}} messageData
  *   Objeto com os campos necessários para persistência.
  * @returns {boolean} true se foi enfileirada; false se inválida/duplicada.
  */
 export function queueMessageInsert(messageData) {
-  if (!messageData?.message_id) return false;
-  if (messagePendingIds.has(messageData.message_id)) return false;
-
   const normalizedMessage = normalizeMessageForQueue(messageData);
+  if (!normalizedMessage?.message_id) return false;
+
+  if (isGroupChatId(normalizedMessage.chat_id) && normalizedMessage.allow_group_write === false) {
+    return false;
+  }
+
+  const pendingKey = buildMessagePendingKey(normalizedMessage.session_id, normalizedMessage.message_id);
+  if (!pendingKey) return false;
+  if (messagePendingIds.has(pendingKey)) return false;
 
   if (messageQueue.length >= MESSAGE_QUEUE_MAX) {
     logger.warn('Fila de mensagens cheia, forçando flush.', { size: messageQueue.length });
     scheduleFlush();
   }
 
-  messagePendingIds.add(normalizedMessage.message_id);
+  messagePendingIds.add(pendingKey);
   messageQueue.push(normalizedMessage);
   updateQueueMetrics();
 
@@ -782,7 +812,7 @@ export function queueChatUpdate(chat, options = {}) {
 /**
  * Enfileira um evento resumido do Baileys para o journal de auditoria.
  *
- * @param {{event_name:string, socket_generation?:(number|null), chat_id?:(string|null), message_id?:(string|null), participant_id?:(string|null), payload_summary?:any, event_timestamp?:(string|number|Date)}} eventData
+ * @param {{session_id?:(string|null), event_name:string, socket_generation?:(number|null), chat_id?:(string|null), message_id?:(string|null), participant_id?:(string|null), payload_summary?:any, event_timestamp?:(string|number|Date)}} eventData
  * @returns {boolean}
  */
 export function queueBaileysEventInsert(eventData) {