@omnizap-system/omnizap 2.5.12

package/scripts/email-broadcast-terms-update.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+
+import { closePool, executeQuery, TABLES } from '../database/index.js';
+import { queueAutomatedEmail } from '../server/email/emailAutomationService.js';
+
+const parseCliArgs = (argv = []) => {
+  const args = new Map();
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = String(argv[index] || '').trim();
+    if (!token.startsWith('--')) continue;
+    const next = String(argv[index + 1] || '').trim();
+    if (!next || next.startsWith('--')) {
+      args.set(token, true);
+      continue;
+    }
+    args.set(token, next);
+    index += 1;
+  }
+  return args;
+};
+
+const parseBoolArg = (value, fallback = false) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  if (value === true) return true;
+  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 parsePositiveInt = (value, fallback = 0) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(0, Math.floor(numeric));
+};
+
+const normalizeEmail = (value) =>
+  String(value || '')
+    .trim()
+    .toLowerCase()
+    .slice(0, 255);
+
+const normalizeText = (value, maxLength = 120) =>
+  String(value || '')
+    .trim()
+    .slice(0, maxLength);
+
+const normalizeTag = (value, fallback) =>
+  String(value || fallback || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9:_-]/g, '')
+    .slice(0, 60);
+
+const nowIsoDate = new Date().toISOString().slice(0, 10);
+const args = parseCliArgs(process.argv.slice(2));
+
+const dryRun = parseBoolArg(args.get('--dry-run'), false);
+const limit = parsePositiveInt(args.get('--limit'), 0);
+const termsUrlArg = normalizeText(args.get('--terms-url') || process.env.EMAIL_TERMS_URL || 'https://omnizap.shop/termos-de-uso/', 2048);
+const subjectArg = normalizeText(args.get('--subject') || 'Atualização dos Termos de Serviço do OmniZap', 180);
+const broadcastTag = normalizeTag(args.get('--tag') || process.env.EMAIL_TERMS_BROADCAST_TAG, nowIsoDate) || nowIsoDate;
+
+const fetchRecipients = async ({ maxRows = 0 } = {}) => {
+  const sqlParts = [`SELECT LOWER(TRIM(email)) AS recipient_email,`, `       MAX(COALESCE(NULLIF(TRIM(name), ''), '')) AS recipient_name,`, `       MAX(COALESCE(last_seen_at, last_login_at, updated_at, created_at)) AS activity_at`, `  FROM ${TABLES.STICKER_WEB_GOOGLE_USER}`, ` WHERE email IS NOT NULL`, `   AND TRIM(email) <> ''`, ` GROUP BY LOWER(TRIM(email))`, ` ORDER BY activity_at DESC`];
+
+  const params = [];
+  if (maxRows > 0) {
+    sqlParts.push(' LIMIT ?');
+    params.push(maxRows);
+  }
+
+  return executeQuery(sqlParts.join('\n'), params);
+};
+
+const run = async () => {
+  const rows = await fetchRecipients({ maxRows: limit });
+  const recipients = [];
+
+  for (const row of rows || []) {
+    const email = normalizeEmail(row?.recipient_email);
+    if (!email || !email.includes('@')) continue;
+    recipients.push({
+      email,
+      name: normalizeText(row?.recipient_name || '', 80),
+    });
+  }
+
+  console.log(`[terms-broadcast] Destinatários elegíveis: ${recipients.length}`);
+  console.log(`[terms-broadcast] Modo: ${dryRun ? 'dry-run' : 'queue-send'}`);
+  console.log(`[terms-broadcast] Tag: ${broadcastTag}`);
+  console.log(`[terms-broadcast] Termos: ${termsUrlArg}`);
+
+  if (!recipients.length) {
+    return {
+      total: 0,
+      queued: 0,
+      failed: 0,
+    };
+  }
+
+  if (dryRun) {
+    const preview = recipients.slice(0, 10).map((item) => `${item.email}${item.name ? ` (${item.name})` : ''}`);
+    console.log('[terms-broadcast] Preview (até 10):');
+    preview.forEach((line) => console.log(` - ${line}`));
+    return {
+      total: recipients.length,
+      queued: 0,
+      failed: 0,
+    };
+  }
+
+  let queued = 0;
+  let failed = 0;
+
+  for (const recipient of recipients) {
+    const idempotencyKey = `terms_update:${broadcastTag}:${recipient.email}`;
+
+    try {
+      const result = await queueAutomatedEmail({
+        to: recipient.email,
+        name: recipient.name,
+        templateKey: 'terms_update',
+        templateData: {
+          name: recipient.name,
+          subject: subjectArg,
+          termsUrl: termsUrlArg,
+        },
+        metadata: {
+          trigger: 'terms_update_broadcast',
+          broadcast_tag: broadcastTag,
+          terms_url: termsUrlArg,
+        },
+        priority: 85,
+        maxAttempts: 5,
+        idempotencyKey,
+      });
+
+      if (result?.task_id) {
+        queued += 1;
+        continue;
+      }
+
+      failed += 1;
+      console.warn(`[terms-broadcast] Falha ao enfileirar: ${recipient.email}`);
+    } catch (error) {
+      failed += 1;
+      console.warn(`[terms-broadcast] Erro para ${recipient.email}: ${error?.message || 'enqueue_failed'}`);
+    }
+  }
+
+  return {
+    total: recipients.length,
+    queued,
+    failed,
+  };
+};
+
+run()
+  .then((summary) => {
+    console.log(`[terms-broadcast] Resumo: total=${summary.total} queued=${summary.queued} failed=${summary.failed}`);
+  })
+  .catch((error) => {
+    console.error(`[terms-broadcast] Falha fatal: ${error?.message || error}`);
+    process.exitCode = 1;
+  })
+  .finally(async () => {
+    await closePool().catch(() => {});
+  });

package/scripts/enrich-command-discovery-fields.mjs

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, '..');
+const modulesRoot = path.join(repoRoot, 'app', 'modules');
+
+const normalizeText = (value) =>
+  String(value || '')
+    .trim()
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^a-z0-9\s/_.-]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+const ensureStringArray = (value) => (Array.isArray(value) ? value.map((item) => String(item || '')).filter(Boolean) : []);
+
+const unique = (values = []) => {
+  const output = [];
+  for (const value of values) {
+    const safe = String(value || '').trim();
+    if (!safe || output.includes(safe)) continue;
+    output.push(safe);
+  }
+  return output;
+};
+
+const cloneLimitProfile = (profile = {}) => ({
+  comum: {
+    max: Number(profile?.comum?.max ?? 12),
+    janela_ms: Number(profile?.comum?.janela_ms ?? 300000),
+    escopo: String(profile?.comum?.escopo || 'usuario').trim() || 'usuario',
+  },
+  premium: {
+    max: Number(profile?.premium?.max ?? 36),
+    janela_ms: Number(profile?.premium?.janela_ms ?? 300000),
+    escopo: String(profile?.premium?.escopo || 'usuario').trim() || 'usuario',
+  },
+});
+
+const LIMIT_PROFILES_BY_CATEGORY = {
+  admin: {
+    comum: { max: 25, janela_ms: 60000, escopo: 'usuario' },
+    premium: { max: 120, janela_ms: 60000, escopo: 'usuario' },
+  },
+  ia: {
+    comum: { max: 8, janela_ms: 300000, escopo: 'usuario' },
+    premium: { max: 40, janela_ms: 300000, escopo: 'usuario' },
+  },
+  midia: {
+    comum: { max: 4, janela_ms: 600000, escopo: 'usuario' },
+    premium: { max: 15, janela_ms: 600000, escopo: 'usuario' },
+  },
+  figurinhas: {
+    comum: { max: 12, janela_ms: 300000, escopo: 'usuario' },
+    premium: { max: 45, janela_ms: 300000, escopo: 'usuario' },
+  },
+  jogos: {
+    comum: { max: 20, janela_ms: 300000, escopo: 'usuario' },
+    premium: { max: 75, janela_ms: 300000, escopo: 'usuario' },
+  },
+  estatisticas: {
+    comum: { max: 25, janela_ms: 60000, escopo: 'usuario' },
+    premium: { max: 120, janela_ms: 60000, escopo: 'usuario' },
+  },
+  menu: {
+    comum: { max: 40, janela_ms: 60000, escopo: 'usuario' },
+    premium: { max: 160, janela_ms: 60000, escopo: 'usuario' },
+  },
+  sistema: {
+    comum: { max: 40, janela_ms: 60000, escopo: 'usuario' },
+    premium: { max: 160, janela_ms: 60000, escopo: 'usuario' },
+  },
+  usuario: {
+    comum: { max: 30, janela_ms: 60000, escopo: 'usuario' },
+    premium: { max: 120, janela_ms: 60000, escopo: 'usuario' },
+  },
+  anime: {
+    comum: { max: 10, janela_ms: 300000, escopo: 'usuario' },
+    premium: { max: 35, janela_ms: 300000, escopo: 'usuario' },
+  },
+  default: {
+    comum: { max: 12, janela_ms: 300000, escopo: 'usuario' },
+    premium: { max: 48, janela_ms: 300000, escopo: 'usuario' },
+  },
+};
+
+const PREMIUM_ONLY_EXACT_COMMANDS = new Set(['wpnsfw', 'playvid', 'catimg']);
+
+const normalizeCategory = (value) =>
+  String(value || '')
+    .trim()
+    .toLowerCase();
+
+const normalizeCommand = (value) =>
+  String(value || '')
+    .trim()
+    .toLowerCase();
+
+const resolveDefaultAccessProfile = (command) => {
+  const category = normalizeCategory(command?.categoria);
+  const commandName = normalizeCommand(command?.name);
+  const profile = LIMIT_PROFILES_BY_CATEGORY[category] || LIMIT_PROFILES_BY_CATEGORY.default;
+  const premiumOnly = PREMIUM_ONLY_EXACT_COMMANDS.has(commandName) || /nsfw/.test(commandName || '');
+
+  return {
+    premiumOnly,
+    limits: cloneLimitProfile(profile),
+  };
+};
+
+const sanitizeLimitEntry = (entry, fallback = {}) => {
+  const max = Number(entry?.max ?? fallback?.max ?? 12);
+  const janelaMs = Number(entry?.janela_ms ?? fallback?.janela_ms ?? 300000);
+  const escopo = String(entry?.escopo || fallback?.escopo || 'usuario').trim() || 'usuario';
+  return {
+    max: Number.isFinite(max) && max > 0 ? Math.floor(max) : Number(fallback?.max ?? 12),
+    janela_ms: Number.isFinite(janelaMs) && janelaMs > 0 ? Math.floor(janelaMs) : Number(fallback?.janela_ms ?? 300000),
+    escopo,
+  };
+};
+
+const ensureAccessAndLimits = (command) => {
+  const defaults = resolveDefaultAccessProfile(command);
+
+  const existingAccess = command?.acesso && typeof command.acesso === 'object' && !Array.isArray(command.acesso) ? command.acesso : {};
+  const existingLimits = command?.limite_uso_por_plano && typeof command.limite_uso_por_plano === 'object' && !Array.isArray(command.limite_uso_por_plano) ? command.limite_uso_por_plano : {};
+
+  const somentePremium = typeof existingAccess.somente_premium === 'boolean' ? existingAccess.somente_premium : defaults.premiumOnly;
+  const planosPermitidosInput = Array.isArray(existingAccess.planos_permitidos)
+    ? existingAccess.planos_permitidos.map((item) =>
+        String(item || '')
+          .trim()
+          .toLowerCase(),
+      )
+    : somentePremium
+      ? ['premium']
+      : ['comum', 'premium'];
+  const planosPermitidos = unique(planosPermitidosInput.filter(Boolean));
+  if (somentePremium && !planosPermitidos.includes('premium')) {
+    planosPermitidos.push('premium');
+  }
+  if (somentePremium) {
+    const idx = planosPermitidos.indexOf('comum');
+    if (idx >= 0) planosPermitidos.splice(idx, 1);
+  }
+
+  const comum = sanitizeLimitEntry(existingLimits.comum, defaults.limits.comum);
+  const premium = sanitizeLimitEntry(existingLimits.premium, defaults.limits.premium);
+  if (premium.max <= comum.max) {
+    premium.max = Math.max(comum.max + 1, Math.floor(comum.max * 2));
+  }
+
+  return {
+    acesso: {
+      somente_premium: somentePremium,
+      planos_permitidos: planosPermitidos,
+    },
+    limite_uso_por_plano: {
+      comum,
+      premium,
+    },
+  };
+};
+
+const buildDefaultCapabilityKeywords = (command) => {
+  const name = String(command?.name || '').trim();
+  const aliases = ensureStringArray(command?.aliases);
+  const category = String(command?.categoria || '').trim();
+  const local = ensureStringArray(command?.local_de_uso);
+  const base = [name, ...aliases];
+  if (category) base.push(category);
+  base.push(...local);
+  return unique(base);
+};
+
+const buildDefaultFaqPatterns = (command) => {
+  const name = String(command?.name || '').trim();
+  if (!name) return [];
+  return unique([`como usar ${name}`, `o que faz ${name}`, `comando ${name}`]);
+};
+
+const buildDefaultUserPhrasings = (command) => {
+  const name = String(command?.name || '').trim();
+  const description = normalizeText(command?.descricao || '');
+  const phrasings = [];
+
+  if (name) {
+    phrasings.push(`quero usar ${name}`);
+    phrasings.push(`me ajuda com ${name}`);
+  }
+  if (description) {
+    const words = description.split(/\s+/).filter(Boolean);
+    if (words.length >= 2) {
+      phrasings.push(words.slice(0, Math.min(4, words.length)).join(' '));
+    }
+  }
+
+  return unique(phrasings);
+};
+
+const listModuleConfigPaths = async () => {
+  const moduleDirs = await fs.readdir(modulesRoot, { withFileTypes: true });
+  const output = [];
+  for (const moduleDir of moduleDirs) {
+    if (!moduleDir.isDirectory()) continue;
+    const configPath = path.join(modulesRoot, moduleDir.name, 'commandConfig.json');
+    try {
+      await fs.access(configPath);
+      output.push(configPath);
+    } catch {
+      // ignore
+    }
+  }
+  return output.sort();
+};
+
+const enrichCommand = (command) => {
+  const next = { ...(command || {}) };
+  if (!Array.isArray(next.capability_keywords)) {
+    next.capability_keywords = buildDefaultCapabilityKeywords(next);
+  } else {
+    next.capability_keywords = unique(next.capability_keywords);
+  }
+
+  if (!Array.isArray(next.faq_patterns)) {
+    next.faq_patterns = buildDefaultFaqPatterns(next);
+  } else {
+    next.faq_patterns = unique(next.faq_patterns);
+  }
+
+  if (!Array.isArray(next.user_phrasings)) {
+    next.user_phrasings = buildDefaultUserPhrasings(next);
+  } else {
+    next.user_phrasings = unique(next.user_phrasings);
+  }
+
+  if (!Number.isFinite(Number(next.suggestion_priority))) {
+    next.suggestion_priority = 100;
+  } else {
+    next.suggestion_priority = Math.max(1, Math.floor(Number(next.suggestion_priority)));
+  }
+
+  const accessAndLimits = ensureAccessAndLimits(next);
+  next.acesso = accessAndLimits.acesso;
+  next.limite_uso_por_plano = accessAndLimits.limite_uso_por_plano;
+
+  return next;
+};
+
+const main = async () => {
+  const configPaths = await listModuleConfigPaths();
+  let updatedFiles = 0;
+
+  for (const configPath of configPaths) {
+    const raw = await fs.readFile(configPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    const commands = Array.isArray(parsed?.commands) ? parsed.commands : [];
+
+    const enrichedCommands = commands.map((command) => enrichCommand(command));
+    const updatedConfig = {
+      ...parsed,
+      commands: enrichedCommands,
+    };
+
+    const serialized = `${JSON.stringify(updatedConfig, null, 2)}\n`;
+    if (serialized !== raw) {
+      await fs.writeFile(configPath, serialized, 'utf8');
+      updatedFiles += 1;
+      console.log(`updated: ${path.relative(repoRoot, configPath)}`);
+    }
+  }
+
+  console.log(`total_updated_files: ${updatedFiles}`);
+};
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});