@omnizap-system/omnizap 2.6.1 → 2.6.3

package/server/controllers/sticker/stickerCatalogController.js

@@ -67,6 +67,7 @@ export const stripWebpExtension = (value) =>
     .replace(/\.webp$/i, '');
 
 const clampInt = (value, fallback, min, max) => {
+  if (value === undefined || value === null || value === '') return fallback;
   const parsed = Number(value);
   if (!Number.isFinite(parsed)) return fallback;
   return Math.max(min, Math.min(max, Math.floor(parsed)));
@@ -964,8 +965,6 @@ const convertUploadMediaToWebp = async ({ ownerJid, buffer, mimetype }) => {
 const PACK_TAG_MARKER_REGEX = /\[pack-tags:([^\]]+)\]/i;
 const AUTO_PACK_MARKER_REGEX = /\[(?:auto-theme|auto-tag):[^\]]+\]/gi;
 const AUTO_PACK_MARKER_TEST_REGEX = /\[(?:auto-theme|auto-tag):[^\]]+\]/i;
-const AUTO_PACK_COLLECTOR_MARKER = '[auto-pack:collector]';
-const AUTO_PACK_COLLECTOR_LEGACY_TEXT = 'coleção automática de figurinhas criadas pelo usuário.';
 const AUTO_PACK_DESCRIPTION_PREFIX_REGEX = /^curadoria automática por tema\.\s*tema:\s*[^.]+\.?\s*(?:score\s*=\s*-?\d+(?:\.\d+)?\.?\s*)?/i;
 const AUTO_PACK_SCORE_FRAGMENT_REGEX = /\bscore\s*=\s*-?\d+(?:\.\d+)?\.?/gi;
 const normalizePackTag = (value) =>
@@ -1024,29 +1023,10 @@ const parsePackDescriptionMetadata = (description) => {
   };
 };
 
-const isCollectorAutoPack = (pack) => {
-  if (!pack || typeof pack !== 'object') return false;
-  const description = String(pack.description || '').toLowerCase();
-  return description.includes(AUTO_PACK_COLLECTOR_MARKER) || description.includes(AUTO_PACK_COLLECTOR_LEGACY_TEXT);
-};
-
-const isThemeCurationAutoPack = (pack) => {
-  if (!pack || typeof pack !== 'object') return false;
-  const name = String(pack.name || '').trim();
-  if (/^\[auto\]/i.test(name)) return true;
-
-  const description = String(pack.description || '').toLowerCase();
-  if (description.includes('[auto-theme:') || description.includes('[auto-tag:')) return true;
-
-  return Boolean(String(pack.pack_theme_key || '').trim());
-};
-
 const shouldHidePackFromMyProfileDefault = (pack, { includeAutoPacks = false } = {}) => {
   if (!pack || typeof pack !== 'object') return false;
   if (includeAutoPacks) return false;
-  if (isCollectorAutoPack(pack)) return false;
-  if (isThemeCurationAutoPack(pack)) return true;
-  return pack.is_auto_pack === true || Number(pack.is_auto_pack || 0) === 1;
+  return false;
 };
 
 const buildPackDescriptionWithTags = (description, tags = []) => {
@@ -1734,6 +1714,12 @@ const getMarketplaceStatsCached = async (visibility) => {
         bucket.expiresAt = __timeNowMs() + HOME_MARKETPLACE_STATS_CACHE_SECONDS * 1000;
         return data;
       })
+      .catch((error) => {
+        if (hasValue && bucket.value) {
+          return bucket.value;
+        }
+        throw error;
+      })
       .finally(() => {
         bucket.pending = null;
       });
@@ -3219,7 +3205,7 @@ const handleCreatePackRequest = async (req, res) => {
   });
   const manualTags = mergeUniqueTags(Array.isArray(payload?.tags) ? payload.tags : []).slice(0, 8);
   const persistedDescription = buildPackDescriptionWithTags(description, manualTags);
-  const visibility = String(payload?.visibility || 'public')
+  const visibility = String(payload?.visibility || 'private')
     .trim()
     .toLowerCase();
   const googleSession = await resolveGoogleWebSessionFromRequest(req);

package/server/controllers/system/contactController.js

@@ -1,13 +1,12 @@
 import logger from '#logger';
 import { getActiveSocket, getAdminPhone, getAdminRawValue, getJidUser, resolveAdminJid, resolveBotJid, extractUserIdInfo, resolveUserId } from '../../../app/config/index.js';
+import { isLikelyWhatsAppPhone, normalizePhoneDigits, resolveAdminPhoneFromEnv, resolveBotPhoneFromEnv, resolveSupportPhoneFromEnv } from '../../../utils/whatsapp/contactEnv.js';
 
 const PACK_COMMAND_PREFIX = String(process.env.COMMAND_PREFIX || '/').trim() || '/';
 
-const normalizePhoneDigits = (value) => String(value || '').replace(/\D+/g, '');
-
 const isPlausibleWhatsAppPhone = (value) => {
   const digits = normalizePhoneDigits(value);
-  return digits.length >= 10 && digits.length <= 15 ? digits : '';
+  return isLikelyWhatsAppPhone(digits) ? digits : '';
 };
 
 const resolveActiveSocketBotJid = (activeSocket) => {
@@ -26,18 +25,12 @@ export const resolveCatalogBotPhone = () => {
   const jidUser = botJid ? getJidUser(botJid) : null;
   const fromSocket = normalizePhoneDigits(jidUser || '');
 
-  if (fromSocket && fromSocket.length >= 10) {
+  if (isLikelyWhatsAppPhone(fromSocket)) {
     return fromSocket;
   }
 
-  const envCandidates = [process.env.WHATSAPP_BOT_NUMBER, process.env.BOT_NUMBER, process.env.PHONE_NUMBER, process.env.BOT_PHONE_NUMBER, process.env.USER_ADMIN];
-
-  for (const candidate of envCandidates) {
-    const digits = normalizePhoneDigits(candidate || '');
-    if (digits && digits.length >= 10 && digits.length <= 15) {
-      return digits;
-    }
-  }
+  const fromEnv = resolveBotPhoneFromEnv({ fallback: '' });
+  if (fromEnv) return fromEnv;
 
   logger.warn('Nao foi possivel resolver o numero do bot para contato.', {
     action: 'resolve_bot_phone_failed',
@@ -75,12 +68,11 @@ const resolveSupportAdminPhone = async () => {
   const adminPhone = isPlausibleWhatsAppPhone(getAdminPhone() || '');
   if (adminPhone) return adminPhone;
 
-  const candidates = [process.env.WHATSAPP_SUPPORT_NUMBER, process.env.OWNER_NUMBER, process.env.USER_ADMIN];
+  const configuredAdminPhone = resolveAdminPhoneFromEnv({ fallback: '' });
+  if (configuredAdminPhone) return configuredAdminPhone;
 
-  for (const candidate of candidates) {
-    const digits = isPlausibleWhatsAppPhone(getJidUser(candidate || '') || candidate);
-    if (digits) return digits;
-  }
+  const configuredSupportPhone = resolveSupportPhoneFromEnv({ fallback: '' });
+  if (configuredSupportPhone) return configuredSupportPhone;
 
   return '';
 };

package/server/controllers/system/stickerCatalogSystemContext.js

@@ -1,5 +1,6 @@
 import { now as __timeNow, nowIso as __timeNowIso, toUnixMs as __timeNowMs } from '#time';
 import { withTimeout } from '../../http/httpRequestUtils.js';
+import { resolveBotPhoneFromEnv } from '../../../utils/whatsapp/contactEnv.js';
 
 export const createStickerCatalogSystemContext = ({ executeQuery, tables, logger, getSystemMetrics, getActiveSocket, resolveSocketReadyState, resolveActiveSocketBotJid, resolveCatalogBotPhone, fetchPrometheusSummary, metricsEndpoint, systemSummaryCache, systemSummaryCacheSeconds, readmeSummaryCache, readmeSummaryCacheSeconds, readmeMessageTypeSampleLimit, readmeCommandPrefix, buildMenuCaption, buildStickerMenu, buildMediaMenu, buildQuoteMenu, buildAnimeMenu, buildAiMenu, buildStatsMenu, buildAdminMenu, profilePictureUrlFromActiveSocket, normalizeJid, getJidUser, globalRankCache, globalRankRefreshSeconds, marketplaceGlobalStatsCache, marketplaceGlobalStatsCacheSeconds }) => {
   let globalRankRefreshTimer = null;
@@ -153,6 +154,12 @@ export const createStickerCatalogSystemContext = ({ executeQuery, tables, logger
           systemSummaryCache.expiresAt = __timeNowMs() + systemSummaryCacheSeconds * 1000;
           return payload;
         })
+        .catch((error) => {
+          if (hasValue && systemSummaryCache.value) {
+            return systemSummaryCache.value;
+          }
+          throw error;
+        })
         .finally(() => {
           systemSummaryCache.pending = null;
         });
@@ -329,6 +336,12 @@ export const createStickerCatalogSystemContext = ({ executeQuery, tables, logger
           readmeSummaryCache.expiresAt = __timeNowMs() + readmeSummaryCacheSeconds * 1000;
           return payload;
         })
+        .catch((error) => {
+          if (hasValue && readmeSummaryCache.value) {
+            return readmeSummaryCache.value;
+          }
+          throw error;
+        })
         .finally(() => {
           readmeSummaryCache.pending = null;
         });
@@ -346,12 +359,8 @@ export const createStickerCatalogSystemContext = ({ executeQuery, tables, logger
     const botPhoneFromCatalog = String(resolveCatalogBotPhone() || '').replace(/\D+/g, '');
     if (botPhoneFromCatalog) candidates.add(botPhoneFromCatalog);
 
-    const envCandidates = [process.env.WHATSAPP_BOT_NUMBER, process.env.BOT_NUMBER, process.env.PHONE_NUMBER, process.env.BOT_PHONE_NUMBER];
-
-    for (const candidate of envCandidates) {
-      const digits = String(candidate || '').replace(/\D+/g, '');
-      if (digits) candidates.add(digits);
-    }
+    const configuredBotPhone = String(resolveBotPhoneFromEnv({ fallback: '' }) || '').replace(/\D+/g, '');
+    if (configuredBotPhone) candidates.add(configuredBotPhone);
 
     return Array.from(candidates).filter((value) => value.length >= 8);
   };
@@ -542,6 +551,12 @@ export const createStickerCatalogSystemContext = ({ executeQuery, tables, logger
           globalRankCache.expiresAt = __timeNowMs() + globalRankRefreshSeconds * 1000;
           return data;
         })
+        .catch((error) => {
+          if (hasValue && globalRankCache.value) {
+            return globalRankCache.value;
+          }
+          throw error;
+        })
         .finally(() => {
           globalRankCache.pending = null;
         });
@@ -737,6 +752,12 @@ export const createStickerCatalogSystemContext = ({ executeQuery, tables, logger
           marketplaceGlobalStatsCache.expiresAt = __timeNowMs() + marketplaceGlobalStatsCacheSeconds * 1000;
           return data;
         })
+        .catch((error) => {
+          if (hasValue && marketplaceGlobalStatsCache.value) {
+            return marketplaceGlobalStatsCache.value;
+          }
+          throw error;
+        })
         .finally(() => {
           marketplaceGlobalStatsCache.pending = null;
         });

package/server/controllers/system/systemController.js

@@ -1,6 +1,6 @@
 import logger from '#logger';
 import { executeQuery, TABLES } from '../../../database/index.js';
-import { getActiveSocket, getJidUser, normalizeJid, profilePictureUrlFromActiveSocket } from '../../../app/config/index.js';
+import { getActiveSocket, getActiveSocketsBySession, getJidUser, getMultiSessionRuntimeConfig, isSocketOpen, normalizeJid, profilePictureUrlFromActiveSocket } from '../../../app/config/index.js';
 import { getSystemMetrics } from '../../../app/utils/systemMetrics/systemMetricsModule.js';
 import { createStickerCatalogSystemContext } from './stickerCatalogSystemContext.js';
 import { createStickerCatalogNonCatalogHandlers } from '../sticker/nonCatalogHandlers.js';
@@ -10,6 +10,9 @@ import { fetchPrometheusSummary } from './systemMetricsController.js';
 import { buildBotContactInfo, buildSupportInfo, resolveCatalogBotPhone } from './contactController.js';
 import { buildAdminMenu, buildAiMenu, buildAnimeMenu, buildMediaMenu, buildMenuCaption, buildQuoteMenu, buildStatsMenu, buildStickerMenu } from '../../../app/modules/menuModule/common.js';
 import { trackWebVisitMetric } from './visitController.js';
+import groupOwnershipService from '../../../app/services/multiSession/groupOwnershipService.js';
+import sessionRegistryService from '../../../app/services/multiSession/sessionRegistryService.js';
+import { runGroupAssignmentBalancerCycle } from '../../../app/services/multiSession/assignmentBalancerService.js';
 
 const SYSTEM_SUMMARY_CACHE_SECONDS = Number(process.env.SYSTEM_SUMMARY_CACHE_SECONDS || 20);
 const README_SUMMARY_CACHE_SECONDS = Number(process.env.README_SUMMARY_CACHE_SECONDS || 1800);
@@ -132,4 +135,228 @@ export const systemHandlers = createStickerCatalogNonCatalogHandlers({
   isAuthenticatedGoogleSession: (sess) => Boolean(sess?.sub && (sess?.ownerJid || sess?.ownerPhone || sess?.email)),
 });
 
+const clampLimit = (value, fallback = 200, min = 1, max = 5_000) => {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(min, Math.min(max, parsed));
+};
+
+const normalizeOptional = (value, maxLength = 255) => {
+  const normalized = String(value || '')
+    .trim()
+    .slice(0, maxLength);
+  return normalized || null;
+};
+
+const normalizeBoolean = (value, fallback = false) => {
+  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 toIso = (value) => {
+  if (!value) return null;
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return null;
+  return parsed.toISOString();
+};
+
+const resolveSocketRuntimeState = (socket) => {
+  const open = isSocketOpen(socket);
+  const readyState = resolveSocketReadyState(socket);
+  const botJid = resolveActiveSocketBotJid(socket);
+  return {
+    socket_open: open,
+    socket_ready_state: readyState,
+    socket_bot_jid: botJid || null,
+  };
+};
+
+export const listSystemAdminSessions = async ({ status = null, limit = 200 } = {}) => {
+  const runtimeConfig = getMultiSessionRuntimeConfig();
+  const safeStatus = normalizeOptional(status, 24);
+  const safeLimit = clampLimit(limit, 200, 1, 5_000);
+  const registryRows = await sessionRegistryService.listSessions({
+    status: safeStatus,
+    limit: safeLimit,
+  });
+
+  const socketsBySession = getActiveSocketsBySession();
+  const knownSessionIds = new Set();
+  for (const sessionId of runtimeConfig.sessionIds || []) knownSessionIds.add(sessionId);
+  for (const row of registryRows || []) {
+    if (row?.sessionId) knownSessionIds.add(row.sessionId);
+  }
+
+  const selectedSessionIds = Array.from(knownSessionIds).filter(Boolean).slice(0, safeLimit);
+  const registryBySession = new Map((registryRows || []).map((row) => [row.sessionId, row]));
+
+  const sessions = selectedSessionIds.map((sessionId) => {
+    const row = registryBySession.get(sessionId) || null;
+    const socket = socketsBySession.get(sessionId) || null;
+    const socketRuntime = resolveSocketRuntimeState(socket);
+
+    return {
+      session_id: sessionId,
+      is_primary: sessionId === runtimeConfig.primarySessionId,
+      configured: (runtimeConfig.sessionIds || []).includes(sessionId),
+      configured_weight: Number(runtimeConfig.sessionWeights?.[sessionId] || 1),
+      status: row?.status || (socketRuntime.socket_open ? 'online' : 'offline'),
+      bot_jid: row?.botJid || socketRuntime.socket_bot_jid || null,
+      capacity_weight: Number(row?.capacityWeight || runtimeConfig.sessionWeights?.[sessionId] || 1),
+      current_score: Number(row?.currentScore || 0),
+      last_heartbeat_at: toIso(row?.lastHeartbeatAt),
+      last_connected_at: toIso(row?.lastConnectedAt),
+      last_disconnected_at: toIso(row?.lastDisconnectedAt),
+      updated_at: toIso(row?.updatedAt),
+      metadata: row?.metadata || null,
+      ...socketRuntime,
+    };
+  });
+
+  return {
+    generated_at: new Date().toISOString(),
+    primary_session_id: runtimeConfig.primarySessionId,
+    configured_session_ids: runtimeConfig.sessionIds || [],
+    sessions,
+  };
+};
+
+export const listSystemAdminAssignments = async ({ groupJid = null, ownerSessionId = null, includeExpired = false, limit = 200 } = {}) => {
+  const safeGroupJid = normalizeOptional(groupJid, 255);
+  const safeOwnerSessionId = normalizeOptional(ownerSessionId, 64);
+  const safeIncludeExpired = normalizeBoolean(includeExpired, false);
+  const safeLimit = clampLimit(limit, 200, 1, 5_000);
+
+  const assignments = await groupOwnershipService.listAssignments({
+    groupJid: safeGroupJid,
+    ownerSessionId: safeOwnerSessionId,
+    includeExpired: safeIncludeExpired,
+    limit: safeLimit,
+  });
+
+  return {
+    generated_at: new Date().toISOString(),
+    filters: {
+      group_jid: safeGroupJid,
+      owner_session_id: safeOwnerSessionId,
+      include_expired: safeIncludeExpired,
+      limit: safeLimit,
+    },
+    assignments: (assignments || []).map((assignment) => ({
+      group_jid: assignment?.groupJid || null,
+      owner_session_id: assignment?.ownerSessionId || null,
+      lease_expires_at: toIso(assignment?.leaseExpiresAt),
+      cooldown_until: toIso(assignment?.cooldownUntil),
+      assignment_version: Number(assignment?.assignmentVersion || 1),
+      pinned: assignment?.pinned === true,
+      active: assignment?.active !== false,
+      last_reason: assignment?.lastReason || null,
+      created_at: toIso(assignment?.createdAt),
+      updated_at: toIso(assignment?.updatedAt),
+    })),
+  };
+};
+
+export const setSystemAdminGroupPin = async ({ groupJid, pinned, sessionId = null, reason = null, changedBy = 'admin_api', metadata = null } = {}) => {
+  const outcome = await groupOwnershipService.setPinned({
+    groupJid,
+    pinned,
+    sessionId,
+    reason: reason || (pinned ? 'admin_pin_group' : 'admin_unpin_group'),
+    changedBy,
+    metadata,
+  });
+
+  return {
+    updated: Boolean(outcome?.updated),
+    reason: outcome?.reason || null,
+    assignment_version: Number(outcome?.assignmentVersion || 0) || null,
+    previous_owner_session_id: outcome?.previousOwnerSessionId || null,
+    owner: outcome?.owner
+      ? {
+          group_jid: outcome.owner.groupJid,
+          owner_session_id: outcome.owner.ownerSessionId,
+          lease_expires_at: toIso(outcome.owner.leaseExpiresAt),
+          cooldown_until: toIso(outcome.owner.cooldownUntil),
+          assignment_version: Number(outcome.owner.assignmentVersion || 1),
+          pinned: outcome.owner.pinned === true,
+          last_reason: outcome.owner.lastReason || null,
+        }
+      : null,
+  };
+};
+
+export const forceSystemAdminGroupFailover = async ({ groupJid, targetSessionId, reason = 'admin_force_failover', changedBy = 'admin_api', metadata = null } = {}) => {
+  const outcome = await groupOwnershipService.forceAssign({
+    groupJid,
+    sessionId: targetSessionId,
+    reason,
+    changedBy,
+    metadata,
+  });
+
+  return {
+    reassigned: Boolean(outcome?.reassigned),
+    reason: outcome?.reason || null,
+    assignment_version: Number(outcome?.assignmentVersion || 0) || null,
+    previous_owner_session_id: outcome?.previousOwnerSessionId || null,
+    owner: outcome?.owner
+      ? {
+          group_jid: outcome.owner.groupJid,
+          owner_session_id: outcome.owner.ownerSessionId,
+          lease_expires_at: toIso(outcome.owner.leaseExpiresAt),
+          assignment_version: Number(outcome.owner.assignmentVersion || 1),
+          pinned: outcome.owner.pinned === true,
+          last_reason: outcome.owner.lastReason || null,
+        }
+      : null,
+  };
+};
+
+export const triggerSystemAdminManualRebalance = async () => {
+  const cycle = await runGroupAssignmentBalancerCycle();
+  return {
+    generated_at: new Date().toISOString(),
+    cycle,
+  };
+};
+
+export const listSystemAdminAssignmentHistory = async ({ groupJid = null, limit = 100 } = {}) => {
+  const safeLimit = clampLimit(limit, 100, 1, 5_000);
+  const safeGroupJid = normalizeOptional(groupJid, 255);
+  const params = [];
+  const where = [];
+  if (safeGroupJid) {
+    where.push('group_jid = ?');
+    params.push(safeGroupJid);
+  }
+
+  const rows = await executeQuery(
+    `SELECT id, group_jid, previous_session_id, new_session_id, change_reason, changed_by, assignment_version, metadata, created_at
+       FROM ${TABLES.GROUP_ASSIGNMENT_HISTORY}
+       ${where.length > 0 ? `WHERE ${where.join(' AND ')}` : ''}
+      ORDER BY id DESC
+      LIMIT ${safeLimit}`,
+    params,
+  );
+
+  return {
+    generated_at: new Date().toISOString(),
+    history: (Array.isArray(rows) ? rows : []).map((row) => ({
+      id: Number(row?.id || 0),
+      group_jid: row?.group_jid || null,
+      previous_session_id: row?.previous_session_id || null,
+      new_session_id: row?.new_session_id || null,
+      change_reason: row?.change_reason || null,
+      changed_by: row?.changed_by || null,
+      assignment_version: Number(row?.assignment_version || 0) || null,
+      metadata: row?.metadata || null,
+      created_at: toIso(row?.created_at),
+    })),
+  };
+};
+
 export { scheduleGlobalRankingPreload };

package/server/controllers/userController.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 
 import logger from '#logger';
 import { DEFAULT_LEGACY_STICKER_API_BASE_PATH, DEFAULT_USER_API_BASE_PATH, isUserApiPath, normalizeBasePath, resolveLegacyUserApiPath } from '../routes/user/userApiPaths.js';
+import { buildWhatsappUrl, resolvePublicWhatsappNumber } from '../utils/publicContact.js';
 
 const LEGACY_STICKER_API_BASE_PATH = normalizeBasePath(process.env.STICKER_API_BASE_PATH, DEFAULT_LEGACY_STICKER_API_BASE_PATH);
 const USER_API_BASE_PATH = normalizeBasePath(process.env.USER_API_BASE_PATH || process.env.AUTH_API_BASE_PATH, DEFAULT_USER_API_BASE_PATH);
@@ -11,6 +12,8 @@ const USER_PROFILE_WEB_PATH = normalizeBasePath(process.env.USER_PROFILE_WEB_PAT
 const USER_PASSWORD_RESET_WEB_PATH = normalizeBasePath(process.env.USER_PASSWORD_RESET_WEB_PATH, '/user/password-reset');
 const USER_DASHBOARD_TEMPLATE_PATH = path.join(process.cwd(), 'public', 'pages', 'user.html');
 const USER_PASSWORD_RESET_TEMPLATE_PATH = path.join(process.cwd(), 'public', 'pages', 'user-password-reset.html');
+const PUBLIC_WHATSAPP_NUMBER = resolvePublicWhatsappNumber();
+const PUBLIC_WHATSAPP_URL = buildWhatsappUrl(PUBLIC_WHATSAPP_NUMBER);
 
 const hasPathPrefix = (pathname, prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`);
 const escapeHtmlAttribute = (value) =>
@@ -52,7 +55,10 @@ const renderUserDashboardHtml = async ({ passwordReset = false } = {}) => {
   const dataAttributes = {
     'data-api-base-path': USER_API_BASE_PATH,
     'data-login-path': STICKER_LOGIN_WEB_PATH,
+    'data-panel-path': USER_PROFILE_WEB_PATH,
     'data-password-reset-web-path': USER_PASSWORD_RESET_WEB_PATH,
+    'data-support-whatsapp-number': PUBLIC_WHATSAPP_NUMBER,
+    'data-support-whatsapp-url': PUBLIC_WHATSAPP_URL,
   };
 
   let html = template;

package/server/email/emailAutomationRuntime.js

@@ -38,6 +38,19 @@ let inFlight = false;
 let timerHandle = null;
 let nextDelayMs = EMAIL_AUTOMATION_POLL_INTERVAL_MS;
 
+const maskEmailForLogs = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase()
+    .slice(0, 255);
+  const [localPartRaw, domainRaw] = normalized.split('@');
+  const localPart = String(localPartRaw || '').trim();
+  const domain = String(domainRaw || '').trim();
+  if (!localPart || !domain) return 'invalid-email';
+  const localMasked = localPart.length <= 2 ? `${localPart.charAt(0) || '*'}*` : `${localPart.slice(0, 2)}***`;
+  return `${localMasked}@${domain}`;
+};
+
 const applyDelayJitter = (delayMs) => {
   const baseDelay = Math.max(250, Math.floor(Number(delayMs) || 0));
   if (EMAIL_AUTOMATION_IDLE_JITTER_PERCENT <= 0) return baseDelay;
@@ -119,6 +132,16 @@ export const runEmailAutomationTick = async ({ maxPerTick = EMAIL_AUTOMATION_MAX
       });
 
       stats.sent += 1;
+      logger.debug('E-mail da fila entregue com sucesso.', {
+        action: 'email_automation_delivery_succeeded',
+        task_id: task.id,
+        template_key: task.template_key || null,
+        recipient_email_masked: maskEmailForLogs(task.recipient_email),
+        attempts: task.attempts,
+        max_attempts: task.max_attempts,
+        provider_message_id: delivery?.messageId || null,
+        provider_response: delivery?.response || null,
+      });
     } catch (error) {
       stats.failed += 1;
       await failEmailOutboxTask(task.id, {
@@ -129,8 +152,12 @@ export const runEmailAutomationTick = async ({ maxPerTick = EMAIL_AUTOMATION_MAX
       logger.warn('Falha ao entregar e-mail da fila.', {
         action: 'email_automation_delivery_failed',
         task_id: task.id,
-        recipient_email: task.recipient_email,
+        template_key: task.template_key || null,
+        recipient_email_masked: maskEmailForLogs(task.recipient_email),
         attempts: task.attempts,
+        max_attempts: task.max_attempts,
+        retry_delay_seconds: safeRetryDelay,
+        metadata_keys: Object.keys(task?.metadata || {}).slice(0, 20),
         error: error?.message,
       });
     }
@@ -138,6 +165,14 @@ export const runEmailAutomationTick = async ({ maxPerTick = EMAIL_AUTOMATION_MAX
 
   if (stats.claimed > 0) {
     await refreshQueueDepthMetrics().catch(() => null);
+    logger.info('Processamento da fila de e-mail concluído.', {
+      action: 'email_automation_tick_processed',
+      claimed: stats.claimed,
+      sent: stats.sent,
+      failed: stats.failed,
+      max_per_tick: safeMaxPerTick,
+      retry_delay_seconds: safeRetryDelay,
+    });
   }
 
   return stats;

package/server/email/emailAutomationService.js

@@ -1,3 +1,4 @@
+import logger from '#logger';
 import { enqueueEmailOutbox, getEmailOutboxStatusSnapshot } from './emailOutboxRepository.js';
 import { renderEmailTemplate } from './emailTemplateService.js';
 import { getEmailTransportMetadata } from './emailTransportService.js';
@@ -8,6 +9,22 @@ const normalizeEmail = (value) =>
     .toLowerCase()
     .slice(0, 255);
 
+const maskEmailForLogs = (value) => {
+  const normalized = normalizeEmail(value);
+  const [localPartRaw, domainRaw] = normalized.split('@');
+  const localPart = String(localPartRaw || '').trim();
+  const domain = String(domainRaw || '').trim();
+  if (!localPart || !domain) return 'invalid-email';
+  const localMasked = localPart.length <= 2 ? `${localPart.charAt(0) || '*'}*` : `${localPart.slice(0, 2)}***`;
+  return `${localMasked}@${domain}`;
+};
+
+const resolveEmailDomain = (value) => {
+  const normalized = normalizeEmail(value);
+  if (!normalized.includes('@')) return null;
+  return normalized.split('@')[1] || null;
+};
+
 const normalizeOptionalText = (value, maxLength = 500_000) => {
   const normalized =
     String(value || '')
@@ -31,6 +48,12 @@ const resolveEmailBodyFromPayload = ({ templateKey = '', templateData = {}, subj
 
   const renderedTemplate = normalizedTemplateKey ? renderEmailTemplate(normalizedTemplateKey, normalizedTemplateData) : null;
 
+  if (normalizedTemplateKey && !renderedTemplate && !normalizeOptionalText(subject, 180) && !normalizeOptionalText(text, 120_000) && !normalizeOptionalText(html, 500_000)) {
+    const error = new Error(`Template de e-mail inválido ou indisponível: "${normalizedTemplateKey}".`);
+    error.statusCode = 400;
+    throw error;
+  }
+
   const normalizedSubject = normalizeOptionalText(subject, 180) || renderedTemplate?.subject || '';
   const normalizedText = normalizeOptionalText(text, 120_000) || renderedTemplate?.text || null;
   const normalizedHtml = normalizeOptionalText(html, 500_000) || renderedTemplate?.html || null;
@@ -72,6 +95,8 @@ export const queueAutomatedEmail = async ({ to, name = '', templateKey = '', tem
     html,
   });
 
+  const safeMetadata = normalizePayloadObject(metadata);
+
   const taskId = await enqueueEmailOutbox({
     recipientEmail: normalizedEmail,
     recipientName: normalizeOptionalText(name, 120),
@@ -80,7 +105,7 @@ export const queueAutomatedEmail = async ({ to, name = '', templateKey = '', tem
     htmlBody: body.html_body,
     templateKey: body.template_key,
     templatePayload: body.template_payload,
-    metadata: normalizePayloadObject(metadata),
+    metadata: safeMetadata,
     priority,
     scheduledAt,
     maxAttempts,
@@ -93,6 +118,22 @@ export const queueAutomatedEmail = async ({ to, name = '', templateKey = '', tem
     throw error;
   }
 
+  logger.info('E-mail enfileirado para processamento.', {
+    action: 'email_outbox_enqueued',
+    task_id: taskId,
+    template_key: body.template_key || null,
+    recipient_email_masked: maskEmailForLogs(normalizedEmail),
+    recipient_domain: resolveEmailDomain(normalizedEmail),
+    subject_length: body.subject.length,
+    has_text_body: Boolean(body.text_body),
+    has_html_body: Boolean(body.html_body),
+    metadata_keys: Object.keys(safeMetadata).slice(0, 20),
+    priority: Number.isFinite(Number(priority)) ? Number(priority) : null,
+    scheduled_at: scheduledAt ? String(scheduledAt) : null,
+    max_attempts: Number.isFinite(Number(maxAttempts)) ? Number(maxAttempts) : null,
+    idempotency_key_present: Boolean(String(idempotencyKey || '').trim()),
+  });
+
   return {
     task_id: taskId,
     recipient_email: normalizedEmail,