@omnizap-system/omnizap 2.6.2 → 2.6.3

package/app/connection/groupOwnerWriteStateResolver.js

@@ -1,30 +1,62 @@
+/**
+ * Normaliza `assignmentVersion` para um inteiro positivo.
+ * @param {unknown} value
+ * @returns {number | null}
+ */
 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,
-    } = {},
-  ) => {
+/**
+ * @typedef {{
+ *   allowed: boolean,
+ *   ownerSessionId: string | null,
+ *   assignmentVersion: number | null,
+ *   reason: string
+ * }} GroupOwnerWriteResolution
+ */
+/**
+ * @typedef {{
+ *   allowClaim?: boolean,
+ *   bypassCache?: boolean,
+ *   source?: string,
+ *   expectedAssignmentVersion?: number | string | null,
+ *   enforceFence?: boolean
+ * }} GroupOwnerWriteResolverOptions
+ */
+/**
+ * @typedef {{
+ *   buildCacheKeyImpl: (groupJid: string, sessionId: string) => string,
+ *   getOwnerImpl: (groupJid: string, options?: { bypassCache?: boolean }) => Promise<{ ownerSessionId?: string | null, assignmentVersion?: number | string | null } | null | undefined>,
+ *   tryAcquireImpl: (options: {
+ *     groupJid: string,
+ *     sessionId: string,
+ *     reason: string,
+ *     changedBy: string,
+ *     metadata?: Record<string, any>
+ *   }) => Promise<{
+ *     acquired?: boolean,
+ *     reason?: string,
+ *     assignmentVersion?: number | string | null,
+ *     owner?: { ownerSessionId?: string | null, assignmentVersion?: number | string | null } | null
+ *   } | null | undefined>,
+ *   cacheImpl: { get: (key: string) => any, set: (key: string, value: any) => any },
+ *   isGroupJidImpl: (jid: string) => boolean,
+ *   normalizeSessionIdImpl: (sessionId: string | null | undefined) => string,
+ *   loggerImpl: { warn: (message: string, meta?: Record<string, any>) => void },
+ *   defaultAllowClaim?: boolean
+ * }} GroupOwnerWriteResolverDeps
+ */
+/**
+ * Cria um resolvedor de permissão de escrita por ownership de grupo.
+ * @param {GroupOwnerWriteResolverDeps} [deps]
+ * @returns {(groupJid: string, sessionId: string, options?: GroupOwnerWriteResolverOptions) => Promise<GroupOwnerWriteResolution>}
+ */
+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)) {

package/app/connection/socketController.js

@@ -21,20 +21,19 @@ import { extractSenderInfoFromMessage, primeLidCache, resolveUserIdCached, isLid
 import { queueBaileysEventInsert, queueChatUpdate, queueLidUpdate, queueMessageInsert } from '../services/infra/dbWriteQueue.js';
 import { buildGroupMetadataFromGroup, buildGroupMetadataFromUpdate, upsertGroupMetadata, parseParticipantsFromDb } from '../services/group/groupMetadataService.js';
 import { buildMessageData } from '../configParts/messagePersistenceService.js';
-import {
-  getOwner as getGroupOwner,
-  tryAcquire as tryAcquireGroupOwner,
-  heartbeatOwnerSession as heartbeatGroupOwnerSession,
-} from '../services/multiSession/groupOwnershipService.js';
+import { getOwner as getGroupOwner, tryAcquire as tryAcquireGroupOwner, heartbeatOwnerSession as heartbeatGroupOwnerSession } from '../services/multiSession/groupOwnershipService.js';
 import sessionRegistryService from '../services/multiSession/sessionRegistryService.js';
 import { createGroupOwnerWriteStateResolver, normalizeAssignmentVersion } from './groupOwnerWriteStateResolver.js';
 import { useDbAuthState } from './baileysDbAuthState.js';
+import { applyLibsignalRuntimePatch } from './baileysLibsignalPatch.js';
 
 import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+applyLibsignalRuntimePatch();
+
 /**
  * Indica se o ambiente de execução é de produção.
  * @type {boolean}
@@ -139,13 +138,30 @@ const BAILEYS_GROUP_METADATA_CACHE_TTL_SECONDS = parseEnvInt(process.env.BAILEYS
  */
 const BAILEYS_GROUP_METADATA_CACHE_CHECKPERIOD_SECONDS = parseEnvInt(process.env.BAILEYS_GROUP_METADATA_CACHE_CHECKPERIOD_SECONDS, 60, 10, 1800);
 /**
- * Identificador lógico da sessão de autenticação do Baileys no MySQL.
- * Permite isolar múltiplas sessões no mesmo banco.
- * @type {string}
+ * Configuração de runtime para múltiplas sessões do Baileys.
+ * @type {{
+ *   sessionIds?: string[],
+ *   primarySessionId?: string,
+ *   ownerLeaseMs?: number,
+ *   ownerHeartbeatMs?: number,
+ *   sessionWeights?: Record<string, number>
+ * }}
  */
 const MULTI_SESSION_RUNTIME_CONFIG = getMultiSessionRuntimeConfig();
+/**
+ * Lista imutável de IDs de sessão habilitadas.
+ * @type {readonly string[]}
+ */
 const BAILEYS_SESSION_IDS = Object.freeze(Array.isArray(MULTI_SESSION_RUNTIME_CONFIG?.sessionIds) && MULTI_SESSION_RUNTIME_CONFIG.sessionIds.length > 0 ? [...MULTI_SESSION_RUNTIME_CONFIG.sessionIds] : [String(process.env.BAILEYS_AUTH_SESSION_ID || 'default').trim() || 'default']);
+/**
+ * Conjunto para consultas rápidas de sessão válida.
+ * @type {Set<string>}
+ */
 const BAILEYS_SESSION_ID_SET = new Set(BAILEYS_SESSION_IDS);
+/**
+ * ID de sessão principal usado como fallback.
+ * @type {string}
+ */
 const BAILEYS_PRIMARY_SESSION_ID = String(MULTI_SESSION_RUNTIME_CONFIG?.primarySessionId || BAILEYS_SESSION_IDS[0] || 'default').trim() || 'default';
 /**
  * Habilita bootstrap inicial do auth state no MySQL usando os arquivos locais legados.
@@ -178,6 +194,11 @@ const BAILEYS_SINGLE_WRITER_LOCK_NAME_BASE = (() => {
   return `omnizap:baileys:writer:${dbLabel}`;
 })();
 
+/**
+ * Normaliza um ID de sessão, garantindo fallback para a sessão principal.
+ * @param {string | null | undefined} sessionId
+ * @returns {string}
+ */
 const normalizeSessionId = (sessionId) => {
   const normalized = String(sessionId || '').trim();
   if (!normalized) return BAILEYS_PRIMARY_SESSION_ID;
@@ -185,6 +206,11 @@ const normalizeSessionId = (sessionId) => {
   return normalized;
 };
 
+/**
+ * Resolve o nome final do lock de escritor único para uma sessão.
+ * @param {string | null | undefined} sessionId
+ * @returns {string}
+ */
 const getWriterLockNameBySession = (sessionId) => {
   const safeSessionId = normalizeSessionId(sessionId);
   const base = BAILEYS_SINGLE_WRITER_LOCK_NAME_BASE;
@@ -194,29 +220,45 @@ const getWriterLockNameBySession = (sessionId) => {
   return `${base}:${safeSessionId}`;
 };
 
-const GROUP_OWNER_WRITE_CACHE_TTL_MS = parseEnvInt(
-  process.env.GROUP_OWNER_WRITE_CACHE_TTL_MS,
-  Math.max(2_000, Math.floor((Number(MULTI_SESSION_RUNTIME_CONFIG?.ownerHeartbeatMs) || 30_000) / 3)),
-  1_000,
-  60_000,
-);
+/**
+ * TTL do cache local de ownership de grupo (em milissegundos).
+ * @type {number}
+ */
+const GROUP_OWNER_WRITE_CACHE_TTL_MS = parseEnvInt(process.env.GROUP_OWNER_WRITE_CACHE_TTL_MS, Math.max(2_000, Math.floor((Number(MULTI_SESSION_RUNTIME_CONFIG?.ownerHeartbeatMs) || 30_000) / 3)), 1_000, 60_000);
+/**
+ * Permite tentar reivindicar ownership no miss de cache.
+ * @type {boolean}
+ */
 const GROUP_OWNER_WRITE_CLAIM_ON_MISS = parseEnvBool(process.env.GROUP_OWNER_WRITE_CLAIM_ON_MISS, true);
+/**
+ * Duração da lease de ownership por sessão (em milissegundos).
+ * @type {number}
+ */
 const GROUP_OWNER_LEASE_MS = Math.max(5_000, Number(MULTI_SESSION_RUNTIME_CONFIG?.ownerLeaseMs) || 120_000);
-let GROUP_OWNER_HEARTBEAT_MS = parseEnvInt(
-  process.env.GROUP_OWNER_HEARTBEAT_RUNTIME_MS,
-  Math.max(1_000, Math.min(GROUP_OWNER_LEASE_MS - 500, Number(MULTI_SESSION_RUNTIME_CONFIG?.ownerHeartbeatMs) || 30_000)),
-  1_000,
-  5 * 60 * 1000,
-);
+/**
+ * Intervalo de heartbeat de ownership (em milissegundos).
+ * @type {number}
+ */
+let GROUP_OWNER_HEARTBEAT_MS = parseEnvInt(process.env.GROUP_OWNER_HEARTBEAT_RUNTIME_MS, Math.max(1_000, Math.min(GROUP_OWNER_LEASE_MS - 500, Number(MULTI_SESSION_RUNTIME_CONFIG?.ownerHeartbeatMs) || 30_000)), 1_000, 5 * 60 * 1000);
 if (GROUP_OWNER_HEARTBEAT_MS >= GROUP_OWNER_LEASE_MS) {
   GROUP_OWNER_HEARTBEAT_MS = Math.max(1_000, Math.floor(GROUP_OWNER_LEASE_MS / 2));
 }
+/**
+ * Cache local de decisões de escrita por ownership de grupo.
+ * @type {NodeCache}
+ */
 const groupOwnerWriteStateCache = new NodeCache({
   stdTTL: Math.max(1, Math.ceil(GROUP_OWNER_WRITE_CACHE_TTL_MS / 1000)),
   checkperiod: Math.max(1, Math.ceil(GROUP_OWNER_WRITE_CACHE_TTL_MS / 1000)),
   useClones: false,
 });
 
+/**
+ * Monta a chave de cache de ownership para uma combinação sessão+grupo.
+ * @param {string | null | undefined} groupJid
+ * @param {string | null | undefined} sessionId
+ * @returns {string}
+ */
 const buildGroupOwnerWriteCacheKey = (groupJid, sessionId) => {
   const safeGroupJid = String(groupJid || '').trim();
   const safeSessionId = normalizeSessionId(sessionId);
@@ -224,6 +266,11 @@ const buildGroupOwnerWriteCacheKey = (groupJid, sessionId) => {
   return `${safeSessionId}:${safeGroupJid}`;
 };
 
+/**
+ * Remove do cache todas as entradas de ownership da sessão informada.
+ * @param {string | null | undefined} sessionId
+ * @returns {void}
+ */
 const clearGroupOwnerWriteCacheForSession = (sessionId) => {
   const safeSessionId = normalizeSessionId(sessionId);
   const prefix = `${safeSessionId}:`;
@@ -362,6 +409,11 @@ let activeSocket = null;
  */
 const sessionContexts = new Map();
 
+/**
+ * Cria o contexto de runtime inicial para uma sessão.
+ * @param {string} sessionId
+ * @returns {SessionContext}
+ */
 const createSessionContext = (sessionId) => ({
   sessionId,
   socket: null,
@@ -375,6 +427,12 @@ const createSessionContext = (sessionId) => ({
   ownerHeartbeatInFlight: false,
 });
 
+/**
+ * Obtém o contexto de runtime de uma sessão.
+ * @param {string | null | undefined} sessionId
+ * @param {{ createIfMissing?: boolean }} [options]
+ * @returns {SessionContext | null}
+ */
 const getSessionContext = (sessionId, { createIfMissing = true } = {}) => {
   const safeSessionId = normalizeSessionId(sessionId);
   let context = sessionContexts.get(safeSessionId);
@@ -385,6 +443,11 @@ const getSessionContext = (sessionId, { createIfMissing = true } = {}) => {
   return context || null;
 };
 
+/**
+ * Resolve qual socket deve ser exposto como "ativo" no runtime legado.
+ * Prioriza a sessão principal quando conectada.
+ * @returns {import('@whiskeysockets/baileys').WASocket | null}
+ */
 const resolvePreferredActiveSocket = () => {
   const primaryContext = getSessionContext(BAILEYS_PRIMARY_SESSION_ID, { createIfMissing: false });
   if (isSocketOpen(primaryContext?.socket)) return primaryContext.socket;
@@ -396,6 +459,10 @@ const resolvePreferredActiveSocket = () => {
   return primaryContext?.socket || null;
 };
 
+/**
+ * Sincroniza a referência legada `activeSocket` com os contextos por sessão.
+ * @returns {void}
+ */
 const syncLegacyActiveSocketReference = () => {
   activeSocket = resolvePreferredActiveSocket();
 };
@@ -1373,8 +1440,7 @@ const startGroupOwnerHeartbeat = (sessionId, generation) => {
     latestContext.ownerHeartbeatInFlight = true;
     try {
       const socket = latestContext.socket;
-      const botJid =
-        normalizeJid(socket?.user?.id || socket?.authState?.creds?.me?.id || socket?.authState?.creds?.me?.lid) || undefined;
+      const botJid = normalizeJid(socket?.user?.id || socket?.authState?.creds?.me?.id || socket?.authState?.creds?.me?.lid) || undefined;
       const sessionWeight = Math.max(1, Number(MULTI_SESSION_RUNTIME_CONFIG?.sessionWeights?.[safeSessionId] || 1));
       const heartbeatOutcome = await heartbeatGroupOwnerSession({
         sessionId: safeSessionId,
@@ -1532,6 +1598,11 @@ const ensureBaileysWriterLock = async (sessionId) => {
   }
 };
 
+/**
+ * Libera todos os locks de escritor mantidos pelo processo atual.
+ * @param {string} [reason='unknown']
+ * @returns {Promise<void>}
+ */
 const releaseAllBaileysWriterLocks = async (reason = 'unknown') => {
   const targets = Array.from(sessionContexts.keys());
   if (!targets.length) {
@@ -1634,6 +1705,7 @@ const syncGroupsOnConnectionOpen = async (sock) => {
  * Configura autenticação, cria o socket e registra handlers de eventos.
  * Gerencia a lógica de reconexão e a distribuição de eventos.
  * @async
+ * @param {string} [sessionId=BAILEYS_PRIMARY_SESSION_ID] - Sessão alvo da conexão.
  * @returns {Promise<void>} Conclusão da inicialização e do registro de handlers.
  * @throws {Error} Lança erro se a conexão inicial falhar.
  */
@@ -2103,9 +2175,7 @@ export async function connectToWhatsApp(sessionId = BAILEYS_PRIMARY_SESSION_ID)
  */
 export async function connectAllWhatsAppSessions() {
   const results = await Promise.allSettled(BAILEYS_SESSION_IDS.map((sessionId) => connectToWhatsApp(sessionId)));
-  const failures = results
-    .map((result, index) => ({ result, sessionId: BAILEYS_SESSION_IDS[index] }))
-    .filter(({ result }) => result.status === 'rejected');
+  const failures = results.map((result, index) => ({ result, sessionId: BAILEYS_SESSION_IDS[index] })).filter(({ result }) => result.status === 'rejected');
 
   if (failures.length > 0) {
     const error = new Error(`Falha ao conectar ${failures.length}/${BAILEYS_SESSION_IDS.length} sessões do WhatsApp.`);

package/app/connection/socketController.multiSession.test.js

@@ -3,6 +3,10 @@ import assert from 'node:assert/strict';
 
 import { createGroupOwnerWriteStateResolver } from './groupOwnerWriteStateResolver.js';
 
+/**
+ * Cria um cache em memória simples para testes.
+ * @returns {{get: (key: string) => any, set: (key: string, value: any) => boolean, del: (key: string) => boolean, keys: () => string[]}}
+ */
 const createCache = () => {
   const map = new Map();
   return {
@@ -16,9 +20,25 @@ const createCache = () => {
   };
 };
 
+/**
+ * Monta a chave de cache por sessão e grupo.
+ * @param {string} groupJid
+ * @param {string} sessionId
+ * @returns {string}
+ */
 const buildCacheKey = (groupJid, sessionId) => `${sessionId}:${groupJid}`;
 
+/**
+ * Normaliza o ID da sessão para os cenários de teste.
+ * @param {string | null | undefined} value
+ * @returns {string}
+ */
 const normalizeSessionId = (value) => String(value || '').trim() || 'default';
+/**
+ * Verifica se o JID pertence a grupo.
+ * @param {string | null | undefined} jid
+ * @returns {boolean}
+ */
 const isGroupJid = (jid) => String(jid || '').endsWith('@g.us');
 
 test('socketController multi-session: fencing token por assignment_version invalida writer stale', async () => {

package/app/controllers/messagePipeline/preProcessingMiddlewares.js

@@ -1,4 +1,4 @@
-export const createPreProcessingMiddlewares = ({ executeQuery, TABLES, isStatusJid, stopMessagePipeline, handleAntiLink, ensureCommandPrefixForContext, resolveCaptchaByMessage, maybeHandleStartLoginMessage, mergeAnalysisMetadata, ensureGroupConfigForContext, resolveStickerFocusState, resolveStickerFocusMessageClassification, resolveGroupOwnerForContext, ownerEnforcementMode = 'off', primarySessionId = 'default', resolveSenderAdminForContext, isUserAdmin, canSendMessageInStickerFocus, registerMessageUsageInStickerFocus, shouldSendStickerFocusWarning, sendReply, formatStickerFocusRuleLabel, formatRemainingMinutesLabel, logger }) => {
+export const createPreProcessingMiddlewares = ({ executeQuery, TABLES, isStatusJid, stopMessagePipeline, handleAntiLink, ensureCommandPrefixForContext, resolveCaptchaByMessage, maybeHandleStartLoginMessage, mergeAnalysisMetadata, ensureGroupConfigForContext, resolveStickerFocusState, resolveStickerFocusMessageClassification, resolveGroupOwnerForContext, ownerEnforcementMode = 'off', primarySessionId = 'default', allowSelfCommandsOnAppend = true, resolveSenderAdminForContext, isUserAdmin, canSendMessageInStickerFocus, registerMessageUsageInStickerFocus, shouldSendStickerFocusWarning, sendReply, formatStickerFocusRuleLabel, formatRemainingMinutesLabel, logger }) => {
   const normalizedOwnerEnforcementMode = String(ownerEnforcementMode || 'off')
     .trim()
     .toLowerCase();
@@ -156,12 +156,26 @@ export const createPreProcessingMiddlewares = ({ executeQuery, TABLES, isStatusJ
 
   const detectCommandIntentMiddleware = async (ctx) => {
     ctx.hasCommandPrefix = ctx.extractedText.startsWith(ctx.commandPrefix);
-    ctx.isCommandMessage = ctx.hasCommandPrefix && ctx.isNotifyUpsert;
+    const isSelfAppendCommand =
+      allowSelfCommandsOnAppend &&
+      ctx.hasCommandPrefix &&
+      !ctx.isNotifyUpsert &&
+      String(ctx.upsertType || '')
+        .trim()
+        .toLowerCase() === 'append' &&
+      ctx.isMessageFromBot;
+    ctx.isCommandMessage = ctx.hasCommandPrefix && (ctx.isNotifyUpsert || isSelfAppendCommand);
 
     ctx.analysisPayload.isCommand = ctx.isCommandMessage;
     ctx.analysisPayload.commandPrefix = ctx.commandPrefix;
 
-    if (ctx.hasCommandPrefix && !ctx.isNotifyUpsert) {
+    if (isSelfAppendCommand) {
+      mergeAnalysisMetadata(ctx.analysisPayload, {
+        command_detected_via: 'append_from_me',
+      });
+    }
+
+    if (ctx.hasCommandPrefix && !ctx.isCommandMessage) {
       mergeAnalysisMetadata(ctx.analysisPayload, {
         command_suppressed_reason: 'non_notify_upsert',
       });

package/app/controllers/messageProcessingPipeline.js

@@ -44,6 +44,7 @@ const MESSAGE_REPLY_PRESENCE_DELAY_MS = parseEnvInt(process.env.MESSAGE_REPLY_PR
 const MESSAGE_REPLY_PRESENCE_SUBSCRIBE = parseEnvBool(process.env.MESSAGE_REPLY_PRESENCE_SUBSCRIBE, true);
 const CONVERSATIONAL_AUTO_REPLY_ENABLED = parseEnvBool(process.env.CONVERSATIONAL_AUTO_REPLY_ENABLED, false);
 const WHATSAPP_COMMAND_REQUIRES_GOOGLE_LOGIN = parseEnvBool(process.env.WHATSAPP_COMMAND_REQUIRES_GOOGLE_LOGIN, true);
+const WHATSAPP_ALLOW_SELF_COMMANDS_ON_APPEND = parseEnvBool(process.env.WHATSAPP_ALLOW_SELF_COMMANDS_ON_APPEND, true);
 const SITE_ORIGIN =
   String(process.env.SITE_ORIGIN || process.env.WHATSAPP_LOGIN_BASE_URL || 'https://omnizap.shop')
     .trim()
@@ -638,6 +639,7 @@ const { touchSenderLastSeenMiddleware, ignoreUnprocessableMessageMiddleware, enf
   resolveGroupOwnerForContext,
   ownerEnforcementMode: GROUP_OWNER_ENFORCEMENT_MODE,
   primarySessionId: PRIMARY_SESSION_ID,
+  allowSelfCommandsOnAppend: WHATSAPP_ALLOW_SELF_COMMANDS_ON_APPEND,
   resolveSenderAdminForContext,
   isUserAdmin,
   canSendMessageInStickerFocus,

package/app/controllers/messageProcessingPipeline.test.js

@@ -39,19 +39,21 @@ const createContext = (overrides = {}) => ({
   ...overrides,
 });
 
-const createStopMessagePipeline = () => (ctx, processingResult = '', metadataPatch = null) => {
-  if (processingResult) {
-    ctx.analysisPayload.processingResult = processingResult;
-  }
-  if (metadataPatch) {
-    ctx.analysisPayload.metadata = {
-      ...(ctx.analysisPayload.metadata || {}),
-      ...(metadataPatch || {}),
-    };
-  }
-  ctx.pipelineStopped = true;
-  return { stop: true };
-};
+const createStopMessagePipeline =
+  () =>
+  (ctx, processingResult = '', metadataPatch = null) => {
+    if (processingResult) {
+      ctx.analysisPayload.processingResult = processingResult;
+    }
+    if (metadataPatch) {
+      ctx.analysisPayload.metadata = {
+        ...(ctx.analysisPayload.metadata || {}),
+        ...(metadataPatch || {}),
+      };
+    }
+    ctx.pipelineStopped = true;
+    return { stop: true };
+  };
 
 const mergeAnalysisMetadata = (analysisPayload, patch) => {
   analysisPayload.metadata = {

package/app/services/multiSession/assignmentBalancerService.js

@@ -282,12 +282,7 @@ export const runGroupAssignmentBalancerCycle = async () => {
       };
     }
 
-    const [groupCounts, messageRates, errorCounts, assignments] = await Promise.all([
-      fetchGroupCountsBySession(onlineSessionIds),
-      fetchMessagesPerMinuteBySession(onlineSessionIds),
-      fetchRecentErrorsBySession(onlineSessionIds),
-      fetchCandidateAssignments(onlineSessionIds),
-    ]);
+    const [groupCounts, messageRates, errorCounts, assignments] = await Promise.all([fetchGroupCountsBySession(onlineSessionIds), fetchMessagesPerMinuteBySession(onlineSessionIds), fetchRecentErrorsBySession(onlineSessionIds), fetchCandidateAssignments(onlineSessionIds)]);
 
     const nowMs = Date.now();
     const sessionStats = new Map();

package/app/services/multiSession/groupOwnershipRepository.js

@@ -63,9 +63,7 @@ export const normalizeSessionId = (value) => {
 
 export const normalizeReason = (value) => {
   if (value === undefined || value === null) return null;
-  const normalized = String(value)
-    .trim()
-    .slice(0, MAX_REASON_LENGTH);
+  const normalized = String(value).trim().slice(0, MAX_REASON_LENGTH);
   return normalized || null;
 };
 
@@ -143,15 +141,7 @@ export const getAssignmentForUpdate = async (groupJid, connection) => {
   return normalizeAssignmentRow(rows?.[0] || null);
 };
 
-export const listAssignments = async (
-  {
-    groupJid = null,
-    ownerSessionId = null,
-    includeExpired = true,
-    limit = 200,
-  } = {},
-  connection = null,
-) => {
+export const listAssignments = async ({ groupJid = null, ownerSessionId = null, includeExpired = true, limit = 200 } = {}, connection = null) => {
   const safeGroupJid = normalizeGroupJid(groupJid);
   const safeOwnerSessionId = normalizeSessionId(ownerSessionId);
   const safeLimit = clampLimit(limit, 200, 1, 5_000);
@@ -184,15 +174,10 @@ export const listAssignments = async (
     connection,
   );
 
-  return (Array.isArray(rows) ? rows : [])
-    .map((row) => normalizeAssignmentRow(row))
-    .filter(Boolean);
+  return (Array.isArray(rows) ? rows : []).map((row) => normalizeAssignmentRow(row)).filter(Boolean);
 };
 
-export const createAssignment = async (
-  { groupJid, ownerSessionId, leaseExpiresAt, cooldownUntil = null, pinned = false, reason = null, assignmentVersion = 1 } = {},
-  connection = null,
-) => {
+export const createAssignment = async ({ groupJid, ownerSessionId, leaseExpiresAt, cooldownUntil = null, pinned = false, reason = null, assignmentVersion = 1 } = {}, connection = null) => {
   const safeGroupJid = normalizeGroupJid(groupJid);
   const safeOwnerSessionId = normalizeSessionId(ownerSessionId);
   const safeLeaseExpiresAt = toDateOrNull(leaseExpiresAt);
@@ -211,10 +196,7 @@ export const createAssignment = async (
   return getAssignment(safeGroupJid, connection);
 };
 
-export const updateAssignmentOwner = async (
-  { groupJid, ownerSessionId, leaseExpiresAt, reason = null, bumpVersion = true, cooldownUntil = undefined, pinned = undefined } = {},
-  connection = null,
-) => {
+export const updateAssignmentOwner = async ({ groupJid, ownerSessionId, leaseExpiresAt, reason = null, bumpVersion = true, cooldownUntil = undefined, pinned = undefined } = {}, connection = null) => {
   const safeGroupJid = normalizeGroupJid(groupJid);
   const safeOwnerSessionId = normalizeSessionId(ownerSessionId);
   const safeLeaseExpiresAt = toDateOrNull(leaseExpiresAt);
@@ -252,10 +234,7 @@ export const updateAssignmentOwner = async (
   return getAssignment(safeGroupJid, connection);
 };
 
-export const updateAssignmentLease = async (
-  { groupJid, ownerSessionId, leaseExpiresAt, reason = undefined } = {},
-  connection = null,
-) => {
+export const updateAssignmentLease = async ({ groupJid, ownerSessionId, leaseExpiresAt, reason = undefined } = {}, connection = null) => {
   const safeGroupJid = normalizeGroupJid(groupJid);
   const safeOwnerSessionId = normalizeSessionId(ownerSessionId);
   const safeLeaseExpiresAt = toDateOrNull(leaseExpiresAt);
@@ -283,10 +262,7 @@ export const updateAssignmentLease = async (
   return getAssignment(safeGroupJid, connection);
 };
 
-export const expireAssignment = async (
-  { groupJid, ownerSessionId = null, reason = null, bumpVersion = true, leaseExpiresAt = new Date() } = {},
-  connection = null,
-) => {
+export const expireAssignment = async ({ groupJid, ownerSessionId = null, reason = null, bumpVersion = true, leaseExpiresAt = new Date() } = {}, connection = null) => {
   const safeGroupJid = normalizeGroupJid(groupJid);
   if (!safeGroupJid) {
     throw new Error('expireAssignment requer groupJid valido.');
@@ -317,15 +293,7 @@ export const expireAssignment = async (
   return getAssignment(safeGroupJid, connection);
 };
 
-export const renewLeasesByOwner = async (
-  {
-    ownerSessionId,
-    leaseExpiresAt,
-    reason = null,
-    now = undefined,
-  } = {},
-  connection = null,
-) => {
+export const renewLeasesByOwner = async ({ ownerSessionId, leaseExpiresAt, reason = null, now = undefined } = {}, connection = null) => {
   const safeOwnerSessionId = normalizeSessionId(ownerSessionId);
   const safeLeaseExpiresAt = toDateOrNull(leaseExpiresAt);
   const safeNow = now === undefined ? new Date() : toDateOrNull(now) || new Date();
@@ -346,10 +314,7 @@ export const renewLeasesByOwner = async (
   return Number(result?.affectedRows || 0);
 };
 
-export const insertAssignmentHistory = async (
-  { groupJid, previousSessionId = null, newSessionId, changeReason = null, changedBy = 'system', assignmentVersion = 1, metadata = null } = {},
-  connection = null,
-) => {
+export const insertAssignmentHistory = async ({ groupJid, previousSessionId = null, newSessionId, changeReason = null, changedBy = 'system', assignmentVersion = 1, metadata = null } = {}, connection = null) => {
   const safeGroupJid = normalizeGroupJid(groupJid);
   const safePreviousSessionId = normalizeSessionId(previousSessionId);
   const safeNewSessionId = normalizeSessionId(newSessionId) || safePreviousSessionId;