@omnizap-system/omnizap 2.6.2 → 2.6.3

package/app/configParts/sessionConfig.js

@@ -1,8 +1,30 @@
+/**
+ * Sessão padrão usada como fallback.
+ * @type {string}
+ */
 const DEFAULT_SESSION_ID = 'default';
+/**
+ * Tamanho máximo permitido para IDs de sessão.
+ * @type {number}
+ */
 const SESSION_ID_MAX_LENGTH = 64;
+/**
+ * Regex de validação para IDs de sessão.
+ * @type {RegExp}
+ */
 const SESSION_ID_PATTERN = /^[a-zA-Z0-9:_-]+$/;
+/**
+ * Modos de enforcement válidos para ownership de grupo.
+ * @type {Set<string>}
+ */
 const OWNER_ENFORCEMENT_MODES = new Set(['off', 'shadow', 'enforce']);
 
+/**
+ * Converte um valor de ambiente para boolean com fallback.
+ * @param {unknown} value
+ * @param {boolean} fallback
+ * @returns {boolean}
+ */
 const parseEnvBool = (value, fallback) => {
   if (value === undefined || value === null || value === '') return fallback;
   const normalized = String(value).trim().toLowerCase();
@@ -11,20 +33,43 @@ const parseEnvBool = (value, fallback) => {
   return fallback;
 };
 
+/**
+ * Converte um valor em inteiro com limites.
+ * @param {unknown} value
+ * @param {number} fallback
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
 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)));
 };
 
+/**
+ * Faz parse de entradas separadas por vírgula, quebra de linha ou `;`.
+ * @param {unknown} value
+ * @returns {string[]}
+ */
 const parseFlexibleEntries = (value) =>
   String(value || '')
     .split(/[,\n;]+/g)
     .map((entry) => String(entry || '').trim())
     .filter(Boolean);
 
+/**
+ * Normaliza um ID de sessão.
+ * @param {unknown} value
+ * @returns {string}
+ */
 const normalizeSessionId = (value) => String(value || '').trim();
 
+/**
+ * Valida formato e tamanho de ID de sessão.
+ * @param {unknown} value
+ * @returns {boolean}
+ */
 const isValidSessionId = (value) => {
   const normalized = normalizeSessionId(value);
   if (!normalized) return false;
@@ -32,6 +77,14 @@ const isValidSessionId = (value) => {
   return SESSION_ID_PATTERN.test(normalized);
 };
 
+/**
+ * @typedef {{sessionIds: string[], warnings: string[]}} ParsedSessionIds
+ */
+/**
+ * Interpreta lista de sessões do ambiente e aplica fallback legado.
+ * @param {{sessionIdsRaw?: string, legacySessionIdRaw?: string}} [params]
+ * @returns {ParsedSessionIds}
+ */
 const parseSessionIds = ({ sessionIdsRaw = '', legacySessionIdRaw = '' } = {}) => {
   const warnings = [];
   const validSessionIds = [];
@@ -63,6 +116,13 @@ const parseSessionIds = ({ sessionIdsRaw = '', legacySessionIdRaw = '' } = {}) =
   };
 };
 
+/**
+ * Resolve pesos por sessão com validação e defaults.
+ * @param {unknown} rawValue
+ * @param {string[]} sessionIds
+ * @param {string[]} warnings
+ * @returns {Record<string, number>}
+ */
 const parseSessionWeights = (rawValue, sessionIds, warnings) => {
   const allowedSessions = new Set(sessionIds);
   const weights = {};
@@ -102,6 +162,23 @@ const parseSessionWeights = (rawValue, sessionIds, warnings) => {
   return weights;
 };
 
+/**
+ * @typedef {{
+ *   sessionIds: readonly string[],
+ *   primarySessionId: string,
+ *   sessionWeights: Readonly<Record<string, number>>,
+ *   ownerEnforcementMode: 'off'|'shadow'|'enforce',
+ *   ownerLeaseMs: number,
+ *   ownerHeartbeatMs: number,
+ *   balancerEnabled: boolean,
+ *   warnings: readonly string[]
+ * }} MultiSessionRuntimeConfig
+ */
+/**
+ * Resolve a configuração de runtime para múltiplas sessões.
+ * @param {Record<string, any>} [env=process.env]
+ * @returns {MultiSessionRuntimeConfig}
+ */
 export const resolveMultiSessionRuntimeConfig = (env = process.env) => {
   const warnings = [];
   const legacySessionId = normalizeSessionId(env.BAILEYS_AUTH_SESSION_ID) || DEFAULT_SESSION_ID;
@@ -152,6 +229,14 @@ export const resolveMultiSessionRuntimeConfig = (env = process.env) => {
   });
 };
 
+/**
+ * Configuração resolvida uma única vez por processo.
+ * @type {MultiSessionRuntimeConfig}
+ */
 export const multiSessionRuntimeConfig = resolveMultiSessionRuntimeConfig();
 
+/**
+ * Retorna a configuração de runtime multi-sessão.
+ * @returns {MultiSessionRuntimeConfig}
+ */
 export const getMultiSessionRuntimeConfig = () => multiSessionRuntimeConfig;

package/app/connection/baileysCompatibility.test.js

@@ -6,12 +6,21 @@ import test from 'node:test';
 
 import { initAuthCreds, proto } from '@whiskeysockets/baileys';
 
+/**
+ * Referência do fork/branch do Baileys validada pelos testes.
+ * @type {string}
+ */
 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');
 const baileysPackageDir = path.dirname(baileysPackageJsonPath);
 
+/**
+ * Lê um arquivo de tipos dentro do pacote instalado do Baileys.
+ * @param {string} relativePath
+ * @returns {Promise<string>}
+ */
 const readBaileysTypeFile = async (relativePath) => readFile(path.join(baileysPackageDir, relativePath), 'utf8');
 
 test('Auth.d.ts expõe AuthenticationState compatível com SocketConfig.auth', async () => {

package/app/connection/baileysDbAuthState.js

@@ -1,19 +1,69 @@
-import { initAuthCreds, proto } from '@whiskeysockets/baileys';
+import { initAuthCreds, makeCacheableSignalKeyStore, proto } from '@whiskeysockets/baileys';
 import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 
 import { baileysAuthLogger as logger } from '../config/index.js';
 import { TABLES, executeQuery, pool } from '../../database/index.js';
 
+/**
+ * Nome da tabela que persiste o estado de autenticação do Baileys.
+ * @type {string}
+ */
 const AUTH_TABLE = TABLES.BAILEYS_AUTH_STATE;
+/**
+ * Categoria usada para armazenar as credenciais principais.
+ * @type {string}
+ */
 const CREDS_CATEGORY = 'creds';
+/**
+ * Identificador fixo da linha de credenciais.
+ * @type {string}
+ */
 const CREDS_ITEM_ID = 'default';
+/**
+ * Extensão esperada para arquivos de bootstrap de auth state.
+ * @type {string}
+ */
 const AUTH_FILE_EXTENSION = '.json';
+/**
+ * Tipos conhecidos de signal keys persistidos no auth state.
+ * @type {string[]}
+ */
 const KNOWN_SIGNAL_KEY_TYPES = ['pre-key', 'session', 'sender-key', 'sender-key-memory', 'app-state-sync-key', 'app-state-sync-version', 'lid-mapping', 'device-list', 'tctoken'];
+/**
+ * Tipos ordenados por tamanho (desc) para priorizar match de prefixo mais específico.
+ * @type {string[]}
+ */
 const KNOWN_SIGNAL_KEY_TYPES_SORTED = [...KNOWN_SIGNAL_KEY_TYPES].sort((left, right) => right.length - left.length);
+/**
+ * Interpreta uma variável de ambiente booleana com fallback.
+ * @param {unknown} value
+ * @param {boolean} fallback
+ * @returns {boolean}
+ */
+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;
+};
+/**
+ * Habilita cache em memória do key store do Baileys.
+ * @type {boolean}
+ */
+const BAILEYS_AUTH_KEYS_CACHE_ENABLED = parseEnvBool(process.env.BAILEYS_AUTH_KEYS_CACHE_ENABLED, true);
 
+/**
+ * Promise compartilhada para inicialização idempotente da tabela.
+ * @type {Promise<void> | null}
+ */
 let ensureTablePromise = null;
 
+/**
+ * Helpers de serialização JSON que preservam Buffers/Uint8Array.
+ * @type {{replacer: (key: string, value: any) => any, reviver: (key: string, value: any) => any}}
+ */
 const BufferJSON = {
   replacer: (_, value) => {
     if (Buffer.isBuffer(value) || value instanceof Uint8Array || value?.type === 'Buffer') {
@@ -38,20 +88,45 @@ const BufferJSON = {
   },
 };
 
+/**
+ * Monta placeholder SQL para cláusula `IN`.
+ * @param {number} count
+ * @returns {string}
+ */
 const buildInClause = (count) => new Array(count).fill('?').join(', ');
 
+/**
+ * Normaliza o ID de sessão do auth state.
+ * @param {string | null | undefined} sessionId
+ * @returns {string}
+ */
 const normalizeSessionId = (sessionId) => {
   const normalized = String(sessionId || '').trim();
   return normalized || 'default';
 };
 
+/**
+ * Normaliza o identificador de item para armazenamento no banco.
+ * @param {string | null | undefined} value
+ * @returns {string}
+ */
 const normalizeStorageId = (value) =>
   String(value || '')
     .replace(/\//g, '__')
     .replace(/:/g, '-');
 
+/**
+ * Serializa payload para coluna JSON com suporte a Buffer.
+ * @param {any} value
+ * @returns {string}
+ */
 const toJsonPayload = (value) => JSON.stringify(value, BufferJSON.replacer);
 
+/**
+ * Faz parse de payload JSON persistido no banco.
+ * @param {unknown} rawPayload
+ * @returns {any | null}
+ */
 const parseJsonPayload = (rawPayload) => {
   if (rawPayload === null || rawPayload === undefined) return null;
   try {
@@ -65,6 +140,58 @@ const parseJsonPayload = (rawPayload) => {
   }
 };
 
+/**
+ * @typedef {{
+ *   totalRows: number,
+ *   credsRows: number,
+ *   signalKeyRows: number,
+ *   categories: Record<string, number>
+ * }} SessionAuthStateStats
+ */
+/**
+ * Lê estatísticas agregadas do auth state para a sessão.
+ * @param {string} sessionId
+ * @returns {Promise<SessionAuthStateStats>}
+ */
+const readSessionAuthStateStats = async (sessionId) => {
+  const rows = await executeQuery(
+    `
+      SELECT category, COUNT(*) AS total
+        FROM \`${AUTH_TABLE}\`
+       WHERE session_id = ?
+       GROUP BY category
+    `,
+    [sessionId],
+  );
+
+  const stats = {
+    totalRows: 0,
+    credsRows: 0,
+    signalKeyRows: 0,
+    categories: {},
+  };
+
+  for (const row of rows || []) {
+    const category = String(row?.category || '').trim();
+    const total = Number(row?.total || 0);
+    if (!category || total <= 0) continue;
+
+    stats.totalRows += total;
+    stats.categories[category] = total;
+    if (category === CREDS_CATEGORY) {
+      stats.credsRows += total;
+    } else {
+      stats.signalKeyRows += total;
+    }
+  }
+
+  return stats;
+};
+
+/**
+ * Garante a existência da tabela de auth state no banco.
+ * @returns {Promise<void>}
+ */
 const ensureAuthStateTable = async () => {
   if (ensureTablePromise) {
     return ensureTablePromise;
@@ -99,11 +226,15 @@ const ensureAuthStateTable = async () => {
   return ensureTablePromise;
 };
 
-const hasSessionData = async (sessionId) => {
-  const rows = await executeQuery(`SELECT 1 FROM \`${AUTH_TABLE}\` WHERE session_id = ? LIMIT 1`, [sessionId]);
-  return Array.isArray(rows) && rows.length > 0;
-};
-
+/**
+ * Insere ou atualiza uma linha de auth state.
+ * @param {string} sessionId
+ * @param {string} category
+ * @param {string} itemId
+ * @param {any} value
+ * @param {import('mysql2/promise').PoolConnection | null} [connection=null]
+ * @returns {Promise<void>}
+ */
 const upsertAuthRow = async (sessionId, category, itemId, value, connection = null) => {
   const payload = toJsonPayload(value);
   await executeQuery(
@@ -117,10 +248,23 @@ const upsertAuthRow = async (sessionId, category, itemId, value, connection = nu
   );
 };
 
+/**
+ * Remove uma linha de auth state.
+ * @param {string} sessionId
+ * @param {string} category
+ * @param {string} itemId
+ * @param {import('mysql2/promise').PoolConnection | null} [connection=null]
+ * @returns {Promise<void>}
+ */
 const deleteAuthRow = async (sessionId, category, itemId, connection = null) => {
   await executeQuery(`DELETE FROM \`${AUTH_TABLE}\` WHERE session_id = ? AND category = ? AND item_id = ?`, [sessionId, category, itemId], connection);
 };
 
+/**
+ * Lê as credenciais salvas para uma sessão.
+ * @param {string} sessionId
+ * @returns {Promise<import('@whiskeysockets/baileys').AuthenticationCreds | null>}
+ */
 const readCredsFromDb = async (sessionId) => {
   const rows = await executeQuery(`SELECT payload FROM \`${AUTH_TABLE}\` WHERE session_id = ? AND category = ? AND item_id = ? LIMIT 1`, [sessionId, CREDS_CATEGORY, CREDS_ITEM_ID]);
   const payload = rows?.[0]?.payload;
@@ -128,6 +272,14 @@ const readCredsFromDb = async (sessionId) => {
   return parsed || null;
 };
 
+/**
+ * @typedef {{category: string, itemId: string}} AuthFileMetadata
+ */
+/**
+ * Extrai categoria e itemId de um arquivo legado de auth state.
+ * @param {string} fileName
+ * @returns {AuthFileMetadata | null}
+ */
 const parseAuthFileMetadata = (fileName) => {
   if (!fileName || typeof fileName !== 'string' || !fileName.endsWith(AUTH_FILE_EXTENSION)) {
     return null;
@@ -156,11 +308,31 @@ const parseAuthFileMetadata = (fileName) => {
   return null;
 };
 
+/**
+ * Migra auth state legado de arquivos para MySQL, quando necessário.
+ * @param {string} sessionId
+ * @param {string | null} bootstrapFromDir
+ * @returns {Promise<boolean>} `true` quando houve importação de ao menos uma linha.
+ */
 const migrateSessionFromFiles = async (sessionId, bootstrapFromDir) => {
   if (!bootstrapFromDir) return false;
 
-  const existsInDb = await hasSessionData(sessionId);
-  if (existsInDb) return false;
+  const authStatsBeforeMigration = await readSessionAuthStateStats(sessionId);
+  const hasSessionData = authStatsBeforeMigration.totalRows > 0;
+  const hasSignalKeyRows = authStatsBeforeMigration.signalKeyRows > 0;
+  if (hasSessionData && hasSignalKeyRows) return false;
+
+  if (hasSessionData && !hasSignalKeyRows) {
+    logger.warn('Auth state do Baileys está parcial (somente creds) e tentará bootstrap via arquivos.', {
+      action: 'baileys_auth_db_partial_state_detected',
+      sessionId,
+      credsRows: authStatsBeforeMigration.credsRows,
+      signalKeyRows: authStatsBeforeMigration.signalKeyRows,
+      totalRows: authStatsBeforeMigration.totalRows,
+      bootstrapFromDir,
+      table: AUTH_TABLE,
+    });
+  }
 
   let directoryEntries = [];
   try {
@@ -224,6 +396,7 @@ const migrateSessionFromFiles = async (sessionId, bootstrapFromDir) => {
       sessionId,
       importedRows,
       skippedRows,
+      hadPartialState: hasSessionData && !hasSignalKeyRows,
       bootstrapFromDir,
       table: AUTH_TABLE,
     });
@@ -232,6 +405,14 @@ const migrateSessionFromFiles = async (sessionId, bootstrapFromDir) => {
   return importedRows > 0;
 };
 
+/**
+ * Cria implementação de SignalKeyStore persistida em MySQL.
+ * @param {string} sessionId
+ * @returns {{
+ *   get: (type: string, ids: string[]) => Promise<Record<string, any>>,
+ *   set: (data: Record<string, Record<string, any>>) => Promise<void>
+ * }}
+ */
 const createDbSignalKeyStore = (sessionId) => ({
   /**
    * @param {string} type
@@ -330,12 +511,27 @@ export async function useDbAuthState(options = {}) {
     }
   }
 
+  const authStats = await readSessionAuthStateStats(sessionId);
+  if (authStats.totalRows > 0 && authStats.signalKeyRows === 0) {
+    logger.warn('Auth state do Baileys sem signal keys; sessão pode ficar instável até novo pareamento.', {
+      action: 'baileys_auth_db_missing_signal_keys',
+      sessionId,
+      credsRows: authStats.credsRows,
+      signalKeyRows: authStats.signalKeyRows,
+      totalRows: authStats.totalRows,
+      categories: authStats.categories,
+      table: AUTH_TABLE,
+    });
+  }
+
   const creds = (await readCredsFromDb(sessionId)) || initAuthCreds();
+  const keyStore = createDbSignalKeyStore(sessionId);
+  const wrappedKeyStore = BAILEYS_AUTH_KEYS_CACHE_ENABLED ? makeCacheableSignalKeyStore(keyStore, logger) : keyStore;
 
   return {
     state: {
       creds,
-      keys: createDbSignalKeyStore(sessionId),
+      keys: wrappedKeyStore,
     },
     saveCreds: async () => {
       await upsertAuthRow(sessionId, CREDS_CATEGORY, CREDS_ITEM_ID, creds);

package/app/connection/baileysLibsignalPatch.js

@@ -0,0 +1,210 @@
+import logger from '#logger';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Interpreta string/valor de ambiente como boolean.
+ * @param {unknown} value
+ * @param {boolean} fallback
+ * @returns {boolean}
+ */
+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;
+};
+
+/**
+ * Habilita/desabilita patch runtime do libsignal.
+ * @type {boolean}
+ */
+const LIBSIGNAL_RUNTIME_PATCH_ENABLED = parseEnvBool(process.env.BAILEYS_LIBSIGNAL_RUNTIME_PATCH_ENABLED, true);
+/**
+ * Versão lógica do patch aplicado.
+ * @type {string}
+ */
+const PATCH_VERSION = '2026-03-25';
+/**
+ * Marker simbólico para identificar protótipos já patchados.
+ * @type {symbol}
+ */
+const PATCH_MARKER = Symbol.for('omnizap.libsignal.runtimePatch');
+/**
+ * Máximo de sessões fechadas mantidas no SessionRecord.
+ * @type {number}
+ */
+const CLOSED_SESSIONS_MAX = 40;
+
+/**
+ * Garante aplicação única por processo.
+ * @type {boolean}
+ */
+let patchAttempted = false;
+
+/**
+ * Marca um alvo como patchado.
+ * @param {object} target
+ * @param {string} [value=PATCH_VERSION]
+ * @returns {void}
+ */
+const markPatched = (target, value = PATCH_VERSION) => {
+  try {
+    Object.defineProperty(target, PATCH_MARKER, {
+      value,
+      writable: false,
+      enumerable: false,
+      configurable: false,
+    });
+  } catch {
+    // Ignora erros de marcação para não impactar inicialização.
+  }
+};
+
+/**
+ * Verifica se um alvo já recebeu patch runtime.
+ * @param {any} target
+ * @returns {boolean}
+ */
+const isPatched = (target) => Boolean(target?.[PATCH_MARKER]);
+
+/**
+ * Aplica patch no SessionRecord para reduzir ruído de sessões antigas.
+ * @returns {boolean} `true` quando o patch foi aplicado nesta execução.
+ */
+const patchSessionRecordLogging = () => {
+  const SessionRecord = require('libsignal/src/session_record.js');
+  const prototype = SessionRecord?.prototype;
+  if (!prototype || isPatched(prototype)) return false;
+
+  prototype.closeSession = function patchedCloseSession(session) {
+    if (!session || !session.indexInfo) return;
+    if (this.isClosed(session)) return;
+    session.indexInfo.closed = Date.now();
+  };
+
+  prototype.openSession = function patchedOpenSession(session) {
+    if (!session || !session.indexInfo) return;
+    session.indexInfo.closed = -1;
+  };
+
+  prototype.removeOldSessions = function patchedRemoveOldSessions() {
+    while (Object.keys(this.sessions).length > CLOSED_SESSIONS_MAX) {
+      let oldestKey;
+      let oldestSession;
+      for (const [key, session] of Object.entries(this.sessions)) {
+        if (session.indexInfo.closed !== -1 && (!oldestSession || session.indexInfo.closed < oldestSession.indexInfo.closed)) {
+          oldestKey = key;
+          oldestSession = session;
+        }
+      }
+      if (oldestKey) {
+        delete this.sessions[oldestKey];
+      } else {
+        throw new Error('Corrupt sessions object');
+      }
+    }
+  };
+
+  markPatched(prototype);
+  return true;
+};
+
+/**
+ * Aplica patch no SessionCipher para reduzir ruído de decrypt em sessões inválidas.
+ * @returns {boolean} `true` quando o patch foi aplicado nesta execução.
+ */
+const patchSessionCipherNoise = () => {
+  const SessionCipher = require('libsignal/src/session_cipher.js');
+  const errors = require('libsignal/src/errors.js');
+  const prototype = SessionCipher?.prototype;
+  if (!prototype || isPatched(prototype)) return false;
+
+  prototype.decryptWithSessions = async function patchedDecryptWithSessions(data, sessions) {
+    if (!Array.isArray(sessions) || sessions.length === 0) {
+      throw new errors.SessionError('No sessions available');
+    }
+
+    for (const session of sessions) {
+      try {
+        const plaintext = await this.doDecryptWhisperMessage(data, session);
+        if (session?.indexInfo) {
+          session.indexInfo.used = Date.now();
+        }
+        return {
+          session,
+          plaintext,
+        };
+      } catch {
+        // Suprime ruído individual por sessão (Bad MAC esperado em rotação de ratchet).
+      }
+    }
+
+    throw new errors.SessionError('No matching sessions found for message');
+  };
+
+  prototype.decryptWhisperMessage = async function patchedDecryptWhisperMessage(data) {
+    if (!Buffer.isBuffer(data)) {
+      throw new TypeError(`Expected Buffer instead of: ${data?.constructor?.name || typeof data}`);
+    }
+    return await this.queueJob(async () => {
+      const record = await this.getRecord();
+      if (!record) {
+        throw new errors.SessionError('No session record');
+      }
+      const result = await this.decryptWithSessions(data, record.getSessions());
+      const remoteIdentityKey = result?.session?.indexInfo?.remoteIdentityKey;
+      if (!(await this.storage.isTrustedIdentity(this.addr.id, remoteIdentityKey))) {
+        throw new errors.UntrustedIdentityKeyError(this.addr.id, remoteIdentityKey);
+      }
+      // Mantemos comportamento funcional original, apenas sem log verboso por mensagem.
+      await this.storeRecord(record);
+      return result.plaintext;
+    });
+  };
+
+  markPatched(prototype);
+  return true;
+};
+
+/**
+ * Aplica patches runtime do libsignal de forma idempotente.
+ * @returns {void}
+ */
+export const applyLibsignalRuntimePatch = () => {
+  if (patchAttempted) return;
+  patchAttempted = true;
+
+  if (!LIBSIGNAL_RUNTIME_PATCH_ENABLED) {
+    logger.info('Patch runtime do libsignal desativado por variável de ambiente.', {
+      action: 'libsignal_runtime_patch_disabled',
+    });
+    return;
+  }
+
+  try {
+    const recordPatched = patchSessionRecordLogging();
+    const cipherPatched = patchSessionCipherNoise();
+
+    if (!recordPatched && !cipherPatched) {
+      logger.debug('Patch runtime do libsignal já aplicado previamente.', {
+        action: 'libsignal_runtime_patch_already_applied',
+      });
+      return;
+    }
+
+    logger.info('Patch runtime do libsignal aplicado para reduzir ruído de sessão.', {
+      action: 'libsignal_runtime_patch_applied',
+      version: PATCH_VERSION,
+      patchedSessionRecord: recordPatched,
+      patchedSessionCipher: cipherPatched,
+    });
+  } catch (error) {
+    logger.warn('Falha ao aplicar patch runtime do libsignal. Seguindo sem patch.', {
+      action: 'libsignal_runtime_patch_failed',
+      error: error?.message,
+    });
+  }
+};