@omnizap-system/omnizap 2.6.1 → 2.6.2

package/app/configParts/messagePersistenceService.js

@@ -2,6 +2,7 @@ import { now as __timeNow, nowIso as __timeNowIso, toUnixMs as __timeNowMs } fro
 import { baileysConnectionLogger as logger } from './loggerConfig.js';
 import { queueMessageInsert } from '../services/infra/dbWriteQueue.js';
 import { parseEnvBool, parseEnvInt, normalizeJid, isGroupJid, isStatusJid, isBroadcastJid, isNewsletterJid, normalizeWAPresence } from './baileysConfig.js';
+import { getOwner as getGroupOwner, tryAcquire as tryAcquireGroupOwner } from '../services/multiSession/groupOwnershipService.js';
 
 const BAILEYS_SEND_RETRY_ATTEMPTS = parseEnvInt(process.env.BAILEYS_SEND_RETRY_ATTEMPTS, 2, 1, 5);
 const BAILEYS_SEND_RETRY_BASE_DELAY_MS = parseEnvInt(process.env.BAILEYS_SEND_RETRY_BASE_DELAY_MS, 600, 100, 10_000);
@@ -11,11 +12,102 @@ const BAILEYS_REPLY_PRESENCE_SUBSCRIBE = parseEnvBool(process.env.BAILEYS_REPLY_
 const BAILEYS_REPLY_PRESENCE_DELAY_MS = parseEnvInt(process.env.BAILEYS_REPLY_PRESENCE_DELAY_MS, 280, 0, 3_000);
 const BAILEYS_REPLY_PRESENCE_BEFORE = normalizeWAPresence(process.env.BAILEYS_REPLY_PRESENCE_BEFORE, 'composing');
 const BAILEYS_REPLY_PRESENCE_AFTER = normalizeWAPresence(process.env.BAILEYS_REPLY_PRESENCE_AFTER, 'paused');
+const GROUP_WRITE_PERMISSION_CACHE_TTL_MS = parseEnvInt(process.env.GROUP_OWNER_WRITE_CACHE_TTL_MS, 8_000, 1_000, 60_000);
 
 const isPlainObject = (value) => Object.prototype.toString.call(value) === '[object Object]';
 
 const ANY_MESSAGE_CONTENT_PRIMARY_KEYS = new Set(['text', 'image', 'video', 'audio', 'sticker', 'stickerPack', 'stickerPackMessage', 'document', 'event', 'poll', 'contacts', 'location', 'react', 'buttonReply', 'groupInvite', 'listReply', 'pin', 'product', 'sharePhoneNumber', 'requestPhoneNumber', 'forward', 'delete', 'disappearingMessagesInChat', 'limitSharing']);
 const PRESENCE_NON_REPLY_CONTENT_KEYS = new Set(['react', 'delete', 'pin', 'disappearingMessagesInChat']);
+const groupWritePermissionCache = new Map();
+
+const normalizeSessionId = (value) => {
+  const normalized = String(value || '').trim();
+  return normalized || null;
+};
+
+const getCachedGroupWritePermission = (groupJid, sessionId) => {
+  const key = `${sessionId}:${groupJid}`;
+  const cached = groupWritePermissionCache.get(key);
+  if (!cached) return null;
+  if (cached.expiresAtMs <= __timeNowMs()) {
+    groupWritePermissionCache.delete(key);
+    return null;
+  }
+  return cached;
+};
+
+const setCachedGroupWritePermission = (groupJid, sessionId, allowed, ownerSessionId = null) => {
+  const key = `${sessionId}:${groupJid}`;
+  groupWritePermissionCache.set(key, {
+    allowed: Boolean(allowed),
+    ownerSessionId: normalizeSessionId(ownerSessionId),
+    expiresAtMs: __timeNowMs() + GROUP_WRITE_PERMISSION_CACHE_TTL_MS,
+  });
+};
+
+const resolveGroupWritePermission = async (groupJid, sessionId) => {
+  if (!isGroupJid(groupJid) || !sessionId) {
+    return {
+      allowed: true,
+      ownerSessionId: null,
+      reason: 'not_group_or_missing_session',
+    };
+  }
+
+  const cached = getCachedGroupWritePermission(groupJid, sessionId);
+  if (cached) {
+    return {
+      allowed: cached.allowed,
+      ownerSessionId: cached.ownerSessionId,
+      reason: 'cache_hit',
+    };
+  }
+
+  try {
+    const ownerState = await getGroupOwner(groupJid);
+    let ownerSessionId = normalizeSessionId(ownerState?.ownerSessionId);
+    let allowed = false;
+    let reason = 'owned_by_other';
+
+    if (!ownerSessionId) {
+      const claimOutcome = await tryAcquireGroupOwner({
+        groupJid,
+        sessionId,
+        reason: 'send_store_claim',
+        changedBy: sessionId,
+        metadata: {
+          source: 'message_persistence_service',
+          gate: 'group_write',
+        },
+      });
+      ownerSessionId = normalizeSessionId(claimOutcome?.owner?.ownerSessionId);
+      allowed = Boolean(claimOutcome?.acquired && ownerSessionId === sessionId);
+      reason = claimOutcome?.reason || 'claim_attempt';
+    } else {
+      allowed = ownerSessionId === sessionId;
+      reason = allowed ? 'owner_match' : 'owned_by_other';
+    }
+
+    setCachedGroupWritePermission(groupJid, sessionId, allowed, ownerSessionId);
+    return {
+      allowed,
+      ownerSessionId,
+      reason,
+    };
+  } catch (error) {
+    logger.warn('Falha ao validar ownership para persistência de saída em grupo.', {
+      action: 'group_write_permission_resolution_failed',
+      groupJid,
+      sessionId,
+      error: error?.message,
+    });
+    return {
+      allowed: false,
+      ownerSessionId: null,
+      reason: 'resolution_failed',
+    };
+  }
+};
 
 /**
  * Verifica se o payload se parece com AnyMessageContent do Baileys.
@@ -62,6 +154,8 @@ const normalizeSendOptions = (options) => {
  * @param {unknown} options
  * @returns {{
  *   sendOptions: import('@whiskeysockets/baileys').MiscMessageGenerationOptions|undefined,
+ *   sessionId: string | null,
+ *   allowGroupWrite: boolean | undefined,
  *   skipPresenceUpdate: boolean,
  *   presenceBefore: import('@whiskeysockets/baileys').WAPresence,
  *   presenceAfter: import('@whiskeysockets/baileys').WAPresence,
@@ -73,6 +167,8 @@ const resolveRuntimeSendOptions = (options) => {
   if (!isPlainObject(options)) {
     return {
       sendOptions: undefined,
+      sessionId: null,
+      allowGroupWrite: undefined,
       skipPresenceUpdate: false,
       presenceBefore: BAILEYS_REPLY_PRESENCE_BEFORE,
       presenceAfter: BAILEYS_REPLY_PRESENCE_AFTER,
@@ -81,10 +177,12 @@ const resolveRuntimeSendOptions = (options) => {
     };
   }
 
-  const { skipPresenceUpdate, presenceBefore, presenceAfter, presenceDelayMs, presenceSubscribe, ...sendOptions } = options;
+  const { skipPresenceUpdate, presenceBefore, presenceAfter, presenceDelayMs, presenceSubscribe, sessionId, allowGroupWrite, ...sendOptions } = options;
   const normalizedDelay = parseEnvInt(presenceDelayMs, BAILEYS_REPLY_PRESENCE_DELAY_MS, 0, 3_000);
   return {
     sendOptions: Object.keys(sendOptions).length > 0 ? sendOptions : undefined,
+    sessionId: normalizeSessionId(sessionId),
+    allowGroupWrite: typeof allowGroupWrite === 'boolean' ? allowGroupWrite : undefined,
     skipPresenceUpdate: Boolean(skipPresenceUpdate),
     presenceBefore: normalizeWAPresence(presenceBefore, BAILEYS_REPLY_PRESENCE_BEFORE),
     presenceAfter: normalizeWAPresence(presenceAfter, BAILEYS_REPLY_PRESENCE_AFTER),
@@ -163,9 +261,11 @@ const resolveMessageTimestampMs = (msg) => {
  * Normaliza uma mensagem do Baileys para o formato persistido no banco.
  * @param {import('@whiskeysockets/baileys').WAMessage} msg - Mensagem recebida/enviada.
  * @param {string} [senderId] - ID do remetente (opcional).
+ * @param {string|null} [sessionId] - Sessão lógica para persistência.
  * @returns {Object} Objeto com dados prontos para persistencia.
  */
-export const buildMessageData = (msg, senderId) => ({
+export const buildMessageData = (msg, senderId, sessionId = null) => ({
+  session_id: normalizeSessionId(sessionId),
   message_id: msg?.key?.id,
   chat_id: msg?.key?.remoteJid,
   sender_id: senderId || msg?.key?.participant || msg?.key?.remoteJid,
@@ -227,6 +327,40 @@ export async function sendAndStore(sock, jid, content, options) {
 
   const normalizedJid = normalizeJid(jid) || String(jid).trim();
   const runtimeOptions = resolveRuntimeSendOptions(options);
+  const runtimeSessionId = runtimeOptions.sessionId || normalizeSessionId(sock?.__omnizapSessionId);
+  let resolvedGroupWritePermission = null;
+
+  if (isGroupJid(normalizedJid)) {
+    if (runtimeOptions.allowGroupWrite === false) {
+      logger.debug('Envio para grupo ignorado por bloqueio explícito de escrita.', {
+        action: 'send_group_blocked_explicit',
+        groupJid: normalizedJid,
+        sessionId: runtimeSessionId,
+      });
+      return undefined;
+    }
+
+    if (runtimeOptions.allowGroupWrite === true) {
+      resolvedGroupWritePermission = {
+        allowed: true,
+        ownerSessionId: runtimeSessionId,
+        reason: 'explicit_allow',
+      };
+    } else {
+      resolvedGroupWritePermission = await resolveGroupWritePermission(normalizedJid, runtimeSessionId);
+      if (!resolvedGroupWritePermission.allowed) {
+        logger.info('Envio para grupo bloqueado por sessão não-owner.', {
+          action: 'send_group_blocked_non_owner',
+          groupJid: normalizedJid,
+          sessionId: runtimeSessionId,
+          ownerSessionId: resolvedGroupWritePermission.ownerSessionId,
+          reason: resolvedGroupWritePermission.reason,
+        });
+        return undefined;
+      }
+    }
+  }
+
   const normalizedOptions = normalizeSendOptions(runtimeOptions.sendOptions);
   const shouldSendPresence = shouldSendReplyPresence(normalizedJid, content, runtimeOptions);
 
@@ -292,7 +426,13 @@ export async function sendAndStore(sock, jid, content, options) {
   const senderId = sock?.user?.id || sent?.key?.participant;
   if (sent?.key?.id) {
     try {
-      queueMessageInsert(buildMessageData(sent, senderId));
+      const messageData = buildMessageData(sent, senderId, runtimeSessionId);
+      const targetGroupJid = normalizeJid(messageData.chat_id || normalizedJid);
+      if (isGroupJid(targetGroupJid)) {
+        const allowGroupWrite = runtimeOptions.allowGroupWrite === true || resolvedGroupWritePermission?.allowed === true;
+        messageData.allow_group_write = allowGroupWrite;
+      }
+      queueMessageInsert(messageData);
     } catch (error) {
       logger.warn('Falha ao enfileirar mensagem enviada para persistencia.', {
         error: error.message,

package/app/configParts/sessionConfig.js

@@ -0,0 +1,157 @@
+const DEFAULT_SESSION_ID = 'default';
+const SESSION_ID_MAX_LENGTH = 64;
+const SESSION_ID_PATTERN = /^[a-zA-Z0-9:_-]+$/;
+const OWNER_ENFORCEMENT_MODES = new Set(['off', 'shadow', 'enforce']);
+
+const parseEnvBool = (value, fallback) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+};
+
+const parseEnvInt = (value, fallback, min, max) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(parsed)));
+};
+
+const parseFlexibleEntries = (value) =>
+  String(value || '')
+    .split(/[,\n;]+/g)
+    .map((entry) => String(entry || '').trim())
+    .filter(Boolean);
+
+const normalizeSessionId = (value) => String(value || '').trim();
+
+const isValidSessionId = (value) => {
+  const normalized = normalizeSessionId(value);
+  if (!normalized) return false;
+  if (normalized.length > SESSION_ID_MAX_LENGTH) return false;
+  return SESSION_ID_PATTERN.test(normalized);
+};
+
+const parseSessionIds = ({ sessionIdsRaw = '', legacySessionIdRaw = '' } = {}) => {
+  const warnings = [];
+  const validSessionIds = [];
+  const seen = new Set();
+
+  const legacySessionId = normalizeSessionId(legacySessionIdRaw) || DEFAULT_SESSION_ID;
+  const requestedSessionIds = parseFlexibleEntries(sessionIdsRaw);
+  const sourceSessionIds = requestedSessionIds.length > 0 ? requestedSessionIds : [legacySessionId];
+
+  for (const candidate of sourceSessionIds) {
+    const sessionId = normalizeSessionId(candidate);
+    if (!isValidSessionId(sessionId)) {
+      warnings.push(`session_id invalido ignorado: "${candidate}"`);
+      continue;
+    }
+    if (seen.has(sessionId)) continue;
+    seen.add(sessionId);
+    validSessionIds.push(sessionId);
+  }
+
+  if (validSessionIds.length === 0) {
+    validSessionIds.push(DEFAULT_SESSION_ID);
+    warnings.push(`nenhum session_id valido encontrado; usando fallback "${DEFAULT_SESSION_ID}"`);
+  }
+
+  return {
+    sessionIds: validSessionIds,
+    warnings,
+  };
+};
+
+const parseSessionWeights = (rawValue, sessionIds, warnings) => {
+  const allowedSessions = new Set(sessionIds);
+  const weights = {};
+  for (const sessionId of sessionIds) {
+    weights[sessionId] = 1;
+  }
+
+  const entries = parseFlexibleEntries(rawValue);
+  if (entries.length === 0) return weights;
+
+  for (const entry of entries) {
+    const separator = entry.includes('=') ? '=' : entry.includes(':') ? ':' : '';
+    if (!separator) {
+      warnings.push(`peso de sessao invalido (faltando separador "=" ou ":"): "${entry}"`);
+      continue;
+    }
+
+    const [rawSessionId, rawWeight] = entry.split(separator, 2);
+    const sessionId = normalizeSessionId(rawSessionId);
+    if (!isValidSessionId(sessionId)) {
+      warnings.push(`peso ignorado para session_id invalido: "${rawSessionId}"`);
+      continue;
+    }
+    if (!allowedSessions.has(sessionId)) {
+      warnings.push(`peso ignorado para session_id nao listado em BAILEYS_SESSION_IDS: "${sessionId}"`);
+      continue;
+    }
+
+    const weight = parseEnvInt(rawWeight, Number.NaN, 1, 1000);
+    if (!Number.isFinite(weight)) {
+      warnings.push(`peso invalido para "${sessionId}": "${rawWeight}"`);
+      continue;
+    }
+    weights[sessionId] = weight;
+  }
+
+  return weights;
+};
+
+export const resolveMultiSessionRuntimeConfig = (env = process.env) => {
+  const warnings = [];
+  const legacySessionId = normalizeSessionId(env.BAILEYS_AUTH_SESSION_ID) || DEFAULT_SESSION_ID;
+  const { sessionIds, warnings: parseWarnings } = parseSessionIds({
+    sessionIdsRaw: env.BAILEYS_SESSION_IDS,
+    legacySessionIdRaw: legacySessionId,
+  });
+  warnings.push(...parseWarnings);
+
+  const requestedPrimary = normalizeSessionId(env.BAILEYS_PRIMARY_SESSION_ID);
+  let primarySessionId = requestedPrimary || sessionIds[0];
+
+  if (requestedPrimary && !isValidSessionId(requestedPrimary)) {
+    warnings.push(`BAILEYS_PRIMARY_SESSION_ID invalido: "${requestedPrimary}"`);
+    primarySessionId = sessionIds[0];
+  } else if (requestedPrimary && !sessionIds.includes(requestedPrimary)) {
+    warnings.push(`BAILEYS_PRIMARY_SESSION_ID fora da lista de sessoes: "${requestedPrimary}"`);
+    primarySessionId = sessionIds[0];
+  }
+
+  const ownerEnforcementModeRaw = String(env.GROUP_OWNER_ENFORCEMENT_MODE || 'off')
+    .trim()
+    .toLowerCase();
+  const ownerEnforcementMode = OWNER_ENFORCEMENT_MODES.has(ownerEnforcementModeRaw) ? ownerEnforcementModeRaw : 'off';
+  if (!OWNER_ENFORCEMENT_MODES.has(ownerEnforcementModeRaw)) {
+    warnings.push(`GROUP_OWNER_ENFORCEMENT_MODE invalido: "${ownerEnforcementModeRaw}"`);
+  }
+
+  const ownerLeaseMs = parseEnvInt(env.GROUP_OWNER_LEASE_MS, 120_000, 5_000, 15 * 60 * 1000);
+  let ownerHeartbeatMs = parseEnvInt(env.GROUP_OWNER_HEARTBEAT_MS, 30_000, 1_000, 5 * 60 * 1000);
+  if (ownerHeartbeatMs >= ownerLeaseMs) {
+    ownerHeartbeatMs = Math.max(1_000, Math.floor(ownerLeaseMs / 2));
+    warnings.push(`GROUP_OWNER_HEARTBEAT_MS ajustado automaticamente para ${ownerHeartbeatMs}ms (precisa ser menor que lease)`);
+  }
+
+  const balancerEnabled = parseEnvBool(env.GROUP_BALANCER_ENABLED, false);
+  const sessionWeights = parseSessionWeights(env.BAILEYS_SESSION_WEIGHTS, sessionIds, warnings);
+
+  return Object.freeze({
+    sessionIds: Object.freeze([...sessionIds]),
+    primarySessionId,
+    sessionWeights: Object.freeze({ ...sessionWeights }),
+    ownerEnforcementMode,
+    ownerLeaseMs,
+    ownerHeartbeatMs,
+    balancerEnabled,
+    warnings: Object.freeze([...warnings]),
+  });
+};
+
+export const multiSessionRuntimeConfig = resolveMultiSessionRuntimeConfig();
+
+export const getMultiSessionRuntimeConfig = () => multiSessionRuntimeConfig;

package/app/connection/baileysCompatibility.test.js

@@ -6,7 +6,7 @@ import test from 'node:test';
 
 import { initAuthCreds, proto } from '@whiskeysockets/baileys';
 
-const PINNED_BAILEYS_REF = 'github:jlucaso1/Baileys#be89465e07afa871cf3f0e19cabfec9780db6be7';
+const PINNED_BAILEYS_REF = 'github:jlucaso1/Baileys#feat-add-stickerpack-support';
 
 const require = createRequire(import.meta.url);
 const baileysPackageJsonPath = require.resolve('@whiskeysockets/baileys/package.json');

package/app/connection/groupOwnerWriteStateResolver.js

@@ -0,0 +1,109 @@
+export const normalizeAssignmentVersion = (value) => {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  return parsed;
+};
+
+export const createGroupOwnerWriteStateResolver = ({
+  buildCacheKeyImpl,
+  getOwnerImpl,
+  tryAcquireImpl,
+  cacheImpl,
+  isGroupJidImpl,
+  normalizeSessionIdImpl,
+  loggerImpl,
+  defaultAllowClaim = true,
+} = {}) =>
+  async (
+    groupJid,
+    sessionId,
+    {
+      allowClaim = defaultAllowClaim,
+      bypassCache = false,
+      source = 'unknown',
+      expectedAssignmentVersion = null,
+      enforceFence = true,
+    } = {},
+  ) => {
+    const safeGroupJid = String(groupJid || '').trim();
+    const safeSessionId = normalizeSessionIdImpl(sessionId);
+    if (!safeGroupJid || !isGroupJidImpl(safeGroupJid)) {
+      return {
+        allowed: true,
+        ownerSessionId: null,
+        assignmentVersion: null,
+        reason: 'not_group',
+      };
+    }
+
+    const safeExpectedAssignmentVersion = normalizeAssignmentVersion(expectedAssignmentVersion);
+    const cacheKey = buildCacheKeyImpl(safeGroupJid, safeSessionId);
+    const mustBypassCache = bypassCache || Boolean(enforceFence && safeExpectedAssignmentVersion);
+
+    if (!mustBypassCache && cacheKey) {
+      const cached = cacheImpl.get(cacheKey);
+      if (cached && typeof cached === 'object') {
+        return cached;
+      }
+    }
+
+    try {
+      const ownerState = await getOwnerImpl(safeGroupJid, { bypassCache: mustBypassCache });
+      let ownerSessionId = String(ownerState?.ownerSessionId || '').trim() || null;
+      let assignmentVersion = normalizeAssignmentVersion(ownerState?.assignmentVersion);
+      let allowed = false;
+      let reason = 'owned_by_other';
+
+      if (!ownerSessionId && allowClaim) {
+        const claimOutcome = await tryAcquireImpl({
+          groupJid: safeGroupJid,
+          sessionId: safeSessionId,
+          reason: 'writer_gate_claim',
+          changedBy: safeSessionId,
+          metadata: {
+            source,
+            gate: 'group_write',
+          },
+        });
+
+        ownerSessionId = String(claimOutcome?.owner?.ownerSessionId || '').trim() || null;
+        assignmentVersion = normalizeAssignmentVersion(claimOutcome?.assignmentVersion ?? claimOutcome?.owner?.assignmentVersion);
+        allowed = Boolean(claimOutcome?.acquired && ownerSessionId === safeSessionId);
+        reason = claimOutcome?.reason || 'claim_attempt';
+      } else {
+        allowed = Boolean(ownerSessionId && ownerSessionId === safeSessionId);
+        reason = !ownerSessionId ? 'owner_missing' : allowed ? 'owner_match' : 'owned_by_other';
+      }
+
+      if (allowed && enforceFence && safeExpectedAssignmentVersion && assignmentVersion && assignmentVersion !== safeExpectedAssignmentVersion) {
+        allowed = false;
+        reason = 'fence_token_mismatch';
+      }
+
+      const resolved = {
+        allowed,
+        ownerSessionId,
+        assignmentVersion,
+        reason,
+      };
+
+      if (cacheKey) {
+        cacheImpl.set(cacheKey, resolved);
+      }
+      return resolved;
+    } catch (error) {
+      loggerImpl.warn('Falha ao resolver ownership para escrita de grupo.', {
+        action: 'group_owner_write_state_failed',
+        source,
+        sessionId: safeSessionId,
+        groupId: safeGroupJid,
+        error: error?.message,
+      });
+      return {
+        allowed: false,
+        ownerSessionId: null,
+        assignmentVersion: null,
+        reason: 'owner_resolution_failed',
+      };
+    }
+  };