@omnizap-system/omnizap 2.5.12

package/app/modules/systemMetricsModule/pingCommand.js

@@ -0,0 +1,399 @@
+import logger from '#logger';
+import { getSystemMetrics } from '../../utils/systemMetrics/systemMetricsModule.js';
+import { sendAndStore } from '../../services/messaging/messagePersistenceService.js';
+
+const METRICS_ENDPOINT = process.env.METRICS_ENDPOINT || `http://localhost:${process.env.METRICS_PORT || 9102}${process.env.METRICS_PATH || '/metrics'}`;
+const METRICS_TOKEN = String(process.env.METRICS_TOKEN || process.env.METRICS_API_KEY || '').trim();
+const METRICS_TIMEOUT_MS = Number(process.env.METRICS_PING_TIMEOUT_MS || 1500);
+
+const formatLoadAverage = (values) => values.map((value) => value.toFixed(2)).join(' | ');
+
+const formatBytes = (bytes) => {
+  if (!Number.isFinite(bytes)) return 'n/a';
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  let value = bytes;
+  let idx = 0;
+  while (value >= 1024 && idx < units.length - 1) {
+    value /= 1024;
+    idx += 1;
+  }
+  return `${value.toFixed(value >= 100 ? 0 : 2)}${units[idx]}`;
+};
+
+const formatSeconds = (seconds) => {
+  if (!Number.isFinite(seconds)) return 'n/a';
+  const total = Math.max(0, Math.floor(seconds));
+  const days = Math.floor(total / 86400);
+  const hours = Math.floor((total % 86400) / 3600);
+  const minutes = Math.floor((total % 3600) / 60);
+  const secs = total % 60;
+  const time = [hours, minutes, secs].map((value) => String(value).padStart(2, '0')).join(':');
+  return days > 0 ? `${days}d ${time}` : time;
+};
+
+const parseMetricNumber = (value) => {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  if (typeof value !== 'string') return null;
+  const parsed = Number(value.replace(',', '.').trim());
+  return Number.isFinite(parsed) ? parsed : null;
+};
+
+const getStatusLevel = (value, warnAt, criticalAt) => {
+  const numericValue = parseMetricNumber(value);
+  if (numericValue === null) return { emoji: '⚪', label: 'sem dado' };
+  if (numericValue >= criticalAt) return { emoji: '🔴', label: 'crítico' };
+  if (numericValue >= warnAt) return { emoji: '🟡', label: 'atenção' };
+  return { emoji: '🟢', label: 'ok' };
+};
+
+const formatStatusLevel = (status) => `${status.emoji} ${status.label}`;
+
+const padNumber = (value) => String(value).padStart(2, '0');
+
+const formatDateTime = (date = new Date()) => `${padNumber(date.getDate())}/${padNumber(date.getMonth() + 1)}/${date.getFullYear()} ${padNumber(date.getHours())}:${padNumber(date.getMinutes())}:${padNumber(date.getSeconds())}`;
+
+const parseLabels = (raw) => {
+  if (!raw) return {};
+  const labels = {};
+  const regex = /(\w+)="((?:\\.|[^"\\])*)"/g;
+  let match;
+  while ((match = regex.exec(raw)) !== null) {
+    labels[match[1]] = match[2].replace(/\\"/g, '"');
+  }
+  return labels;
+};
+
+const parsePrometheusText = (text) => {
+  const series = new Map();
+  const lines = text.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const [metricPart, valuePart] = trimmed.split(/\s+/, 2);
+    if (!metricPart || !valuePart) continue;
+    const value = Number(valuePart);
+    if (!Number.isFinite(value)) continue;
+    const labelStart = metricPart.indexOf('{');
+    let name = metricPart;
+    let labels = {};
+    if (labelStart !== -1) {
+      name = metricPart.slice(0, labelStart);
+      const labelBody = metricPart.slice(labelStart + 1, metricPart.lastIndexOf('}'));
+      labels = parseLabels(labelBody);
+    }
+    const list = series.get(name) || [];
+    list.push({ labels, value });
+    series.set(name, list);
+  }
+  return series;
+};
+
+const pickValue = (series, name, filter = null) => {
+  const list = series.get(name) || [];
+  if (!list.length) return null;
+  if (!filter) return list[0].value;
+  const hit = list.find((entry) => filter(entry.labels));
+  return hit ? hit.value : null;
+};
+
+const sumValues = (series, name, filter = null) => {
+  const list = series.get(name) || [];
+  return list.reduce((acc, entry) => {
+    if (filter && !filter(entry.labels)) return acc;
+    if (!Number.isFinite(entry.value)) return acc;
+    return acc + entry.value;
+  }, 0);
+};
+
+const getLabelValue = (series, name, labelKey) => {
+  const list = series.get(name) || [];
+  const entry = list.find((item) => item.labels && item.labels[labelKey]);
+  return entry ? entry.labels[labelKey] : null;
+};
+
+const buildPingMessage = ({ systemMetrics, metricsSummary, metricsOk, metricsError, latencyMs, generatedAt }) => {
+  const responseTime = Number.isFinite(latencyMs) ? `${Math.max(0, Math.round(latencyMs))}ms` : 'n/a';
+
+  const hostCpuStatus = getStatusLevel(systemMetrics.usoCpuPercentual, 65, 85);
+  const hostMemoryStatus = getStatusLevel(systemMetrics.usoMemoriaPercentual, 75, 90);
+
+  const load1 = Array.isArray(systemMetrics.cargaMedia) ? systemMetrics.cargaMedia[0] : null;
+  const loadPerCore = Number.isFinite(load1) && systemMetrics.totalCpus > 0 ? load1 / systemMetrics.totalCpus : null;
+  const loadStatus = getStatusLevel(loadPerCore, 0.9, 1.2);
+  const loadPerCoreText = loadPerCore === null ? 'n/a' : loadPerCore.toFixed(2);
+
+  const systemPart = `
+🖥️ *Servidor (máquina)*
+• Host: ${systemMetrics.hostname}
+• SO: ${systemMetrics.plataforma} ${systemMetrics.release} (${systemMetrics.arquitetura})
+• Uptime do sistema: ${systemMetrics.uptimeSistema}
+• CPU da máquina: ${formatStatusLevel(hostCpuStatus)} • ${systemMetrics.usoCpuPercentual}% (uso geral)
+• Carga (1m|5m|15m): ${formatLoadAverage(systemMetrics.cargaMedia)}
+• Pressão por núcleo (1m): ${loadPerCoreText} • ${formatStatusLevel(loadStatus)}
+• RAM: ${formatStatusLevel(hostMemoryStatus)} • ${systemMetrics.memoriaUsada} / ${systemMetrics.memoriaTotal} (${systemMetrics.usoMemoriaPercentual}%)
+`.trim();
+
+  if (!metricsOk) {
+    return `
+🏓 *Pong! Painel de saúde (modo básico)*
+🕐 Atualizado em: ${formatDateTime(generatedAt)}
+⚡ Tempo de resposta: ${responseTime}
+🧭 Legenda: 🟢 ok • 🟡 atenção • 🔴 crítico • ⚪ sem dado
+
+${systemPart}
+
+⚠️ *Métricas avançadas indisponíveis*
+• Motivo: ${metricsError || 'sem detalhes'}
+• Endpoint: ${METRICS_ENDPOINT}
+• Timeout: ${METRICS_TIMEOUT_MS}ms
+
+💡 *Dica:* as métricas avançadas vêm do endpoint */metrics* (Prometheus).
+`.trim();
+  }
+
+  const openFds = parseMetricNumber(metricsSummary.openFds);
+  const maxFds = parseMetricNumber(metricsSummary.maxFds);
+  const fdsUsage = openFds !== null && maxFds && maxFds > 0 ? (openFds / maxFds) * 100 : null;
+  const fdsStatus = getStatusLevel(fdsUsage, 60, 80);
+  const fdsUsageText = fdsUsage === null ? 'n/a' : `${fdsUsage.toFixed(1)}%`;
+
+  const lagP99 = parseMetricNumber(metricsSummary.lagP99);
+  const lagStatus = getStatusLevel(lagP99, 120, 300);
+
+  const dbTotal = parseMetricNumber(metricsSummary.dbTotal) || 0;
+  const dbSlow = parseMetricNumber(metricsSummary.dbSlow) || 0;
+  const slowRate = dbTotal > 0 ? (dbSlow / dbTotal) * 100 : null;
+  const dbStatus = getStatusLevel(slowRate, 5, 15);
+  const slowRateText = slowRate === null ? 'n/a' : `${slowRate.toFixed(2)}%`;
+
+  const queueValues = [metricsSummary.queues.messages, metricsSummary.queues.chats, metricsSummary.queues.lid_map].map((value) => parseMetricNumber(value)).filter((value) => value !== null);
+  const queuePeak = queueValues.length ? Math.max(...queueValues) : null;
+  const queueStatus = getStatusLevel(queuePeak, 30, 120);
+  const queuePeakText = queuePeak === null ? 'n/a' : String(Math.round(queuePeak));
+
+  const processPart = `
+⚙️ *Processo do bot*
+• Uptime do processo: ${metricsSummary.processUptime}
+• Node.js: ${metricsSummary.nodeVersion}
+• CPU acumulada: total ${metricsSummary.cpuTotalSec}s (user ${metricsSummary.cpuUserSec}s | sys ${metricsSummary.cpuSysSec}s)
+• Memória do processo: RSS ${metricsSummary.rss} | Heap ${metricsSummary.heap} | VMem ${metricsSummary.vmem}
+• FDs abertos: ${metricsSummary.openFds}/${metricsSummary.maxFds} (${fdsUsageText}) • ${formatStatusLevel(fdsStatus)}
+`.trim();
+
+  const nodePart = `
+🧠 *Event Loop (responsividade)*
+• Lag p50: ${metricsSummary.lagP50}ms (comportamento normal)
+• Lag p90: ${metricsSummary.lagP90}ms (picos frequentes)
+• Lag p99: ${metricsSummary.lagP99}ms (pior caso recente)
+• Status do loop: ${formatStatusLevel(lagStatus)} (quanto menor o lag, melhor)
+`.trim();
+
+  const dbPart = `
+🗄️ *Banco*
+• Queries totais: ${metricsSummary.dbTotal}
+• Queries lentas: ${metricsSummary.dbSlow} (${slowRateText}) • ${formatStatusLevel(dbStatus)}
+• Writes: messages ${metricsSummary.writes.messages} | lid_map ${metricsSummary.writes.lid_map} | groups ${metricsSummary.writes.groups_metadata}
+• Últimas latências (ms): messages ${metricsSummary.lastQuery.messages} | lid_map ${metricsSummary.lastQuery.lid_map} | groups ${metricsSummary.lastQuery.groups_metadata}
+`.trim();
+
+  const queuePart = `
+📦 *Filas internas (backlog)*
+• messages ${metricsSummary.queues.messages} | chats ${metricsSummary.queues.chats} | lid_map ${metricsSummary.queues.lid_map}
+• Pico atual: ${queuePeakText} • ${formatStatusLevel(queueStatus)} (quanto menor, melhor)
+`.trim();
+
+  const upsertPart = `
+📬 *messages.upsert (entrada de mensagens)*
+• Eventos recebidos: append ${metricsSummary.upsertEvents.append} | notify ${metricsSummary.upsertEvents.notify}
+• Mensagens processadas: append ${metricsSummary.upsertMessages.append} | notify ${metricsSummary.upsertMessages.notify}
+`.trim();
+
+  const glossaryPart = `
+📖 *Glossário rápido*
+• RSS: memória real em RAM usada pelo processo
+• Heap: memória JavaScript gerenciada pelo Node.js
+• VMem: memória virtual reservada pelo processo
+• Lag: atraso do Node para executar tarefas
+`.trim();
+
+  return `
+🏓 *Pong! Painel de saúde do Omnizap*
+🕐 Atualizado em: ${formatDateTime(generatedAt)}
+⚡ Tempo de resposta: ${responseTime}
+🧭 Legenda: 🟢 ok • 🟡 atenção • 🔴 crítico • ⚪ sem dado
+
+${systemPart}
+
+${processPart}
+
+${nodePart}
+
+${dbPart}
+
+${queuePart}
+
+${upsertPart}
+
+${glossaryPart}
+`.trim();
+};
+
+const fetchMetricsSnapshot = async () => {
+  const controller = typeof globalThis.AbortController === 'function' ? new globalThis.AbortController() : null;
+  const timeout = setTimeout(() => controller?.abort(), METRICS_TIMEOUT_MS);
+  try {
+    if (typeof globalThis.fetch !== 'function') {
+      throw new Error('fetch indisponível');
+    }
+    const headers = {};
+    if (METRICS_TOKEN) {
+      headers.Authorization = `Bearer ${METRICS_TOKEN}`;
+    }
+    const response = await globalThis.fetch(METRICS_ENDPOINT, {
+      ...(controller ? { signal: controller.signal } : {}),
+      ...(Object.keys(headers).length ? { headers } : {}),
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const text = await response.text();
+    const series = parsePrometheusText(text);
+
+    const processStart = pickValue(series, 'omnizap_process_start_time_seconds');
+    const nowSec = Date.now() / 1000;
+    const processUptime = processStart ? formatSeconds(nowSec - processStart) : 'n/a';
+
+    const cpuUserSec = pickValue(series, 'omnizap_process_cpu_user_seconds_total');
+    const cpuSysSec = pickValue(series, 'omnizap_process_cpu_system_seconds_total');
+    const cpuTotalSec = pickValue(series, 'omnizap_process_cpu_seconds_total');
+
+    const rss = pickValue(series, 'omnizap_process_resident_memory_bytes');
+    const vmem = pickValue(series, 'omnizap_process_virtual_memory_bytes');
+    const heap = pickValue(series, 'omnizap_process_heap_bytes');
+
+    const openFds = pickValue(series, 'omnizap_process_open_fds');
+    const maxFds = pickValue(series, 'omnizap_process_max_fds');
+
+    const lagP50 = pickValue(series, 'omnizap_nodejs_eventloop_lag_p50_seconds');
+    const lagP90 = pickValue(series, 'omnizap_nodejs_eventloop_lag_p90_seconds');
+    const lagP99 = pickValue(series, 'omnizap_nodejs_eventloop_lag_p99_seconds');
+
+    const nodeVersion = getLabelValue(series, 'omnizap_nodejs_version_info', 'version') || 'n/a';
+
+    const dbTotal = sumValues(series, 'omnizap_db_query_total');
+    const dbSlow = sumValues(series, 'omnizap_db_slow_queries_total');
+
+    const writesByTable = {};
+    const writeSeries = series.get('omnizap_db_write_total') || [];
+    writeSeries.forEach((entry) => {
+      const table = entry.labels?.table || 'unknown';
+      writesByTable[table] = (writesByTable[table] || 0) + entry.value;
+    });
+
+    const lastQuerySeries = series.get('omnizap_db_last_query_duration_ms') || [];
+    const lastQuery = {};
+    lastQuerySeries.forEach((entry) => {
+      const table = entry.labels?.table;
+      if (!table) return;
+      lastQuery[table] = entry.value;
+    });
+
+    const queueSeries = series.get('omnizap_queue_depth') || [];
+    const queues = {};
+    queueSeries.forEach((entry) => {
+      const queue = entry.labels?.queue;
+      if (!queue) return;
+      queues[queue] = entry.value;
+    });
+
+    const upsertEvents = {};
+    const upsertSeries = series.get('omnizap_messages_upsert_total') || [];
+    upsertSeries.forEach((entry) => {
+      const type = entry.labels?.type || 'unknown';
+      upsertEvents[type] = (upsertEvents[type] || 0) + entry.value;
+    });
+
+    const upsertMessages = {};
+    const upsertMsgSeries = series.get('omnizap_messages_upsert_messages_total') || [];
+    upsertMsgSeries.forEach((entry) => {
+      const type = entry.labels?.type || 'unknown';
+      upsertMessages[type] = (upsertMessages[type] || 0) + entry.value;
+    });
+
+    const formatNumber = (value, digits = 2) => (Number.isFinite(value) ? value.toFixed(digits) : 'n/a');
+
+    return {
+      processUptime,
+      cpuUserSec: formatNumber(cpuUserSec),
+      cpuSysSec: formatNumber(cpuSysSec),
+      cpuTotalSec: formatNumber(cpuTotalSec),
+      rss: formatBytes(rss),
+      heap: formatBytes(heap),
+      vmem: formatBytes(vmem),
+      openFds: Number.isFinite(openFds) ? Math.round(openFds) : 'n/a',
+      maxFds: Number.isFinite(maxFds) ? Math.round(maxFds) : 'n/a',
+      nodeVersion,
+      lagP50: Number.isFinite(lagP50) ? (lagP50 * 1000).toFixed(2) : 'n/a',
+      lagP90: Number.isFinite(lagP90) ? (lagP90 * 1000).toFixed(2) : 'n/a',
+      lagP99: Number.isFinite(lagP99) ? (lagP99 * 1000).toFixed(2) : 'n/a',
+      dbTotal: Math.round(dbTotal),
+      dbSlow: Math.round(dbSlow),
+      writes: {
+        messages: Math.round(writesByTable.messages || 0),
+        lid_map: Math.round(writesByTable.lid_map || 0),
+        groups_metadata: Math.round(writesByTable.groups_metadata || 0),
+      },
+      lastQuery: {
+        messages: Number.isFinite(lastQuery.messages) ? lastQuery.messages.toFixed(2) : 'n/a',
+        lid_map: Number.isFinite(lastQuery.lid_map) ? lastQuery.lid_map.toFixed(2) : 'n/a',
+        groups_metadata: Number.isFinite(lastQuery.groups_metadata) ? lastQuery.groups_metadata.toFixed(2) : 'n/a',
+      },
+      queues: {
+        messages: Math.round(queues.messages || 0),
+        chats: Math.round(queues.chats || 0),
+        lid_map: Math.round(queues.lid_map || 0),
+      },
+      upsertEvents: {
+        append: Math.round(upsertEvents.append || 0),
+        notify: Math.round(upsertEvents.notify || 0),
+      },
+      upsertMessages: {
+        append: Math.round(upsertMessages.append || 0),
+        notify: Math.round(upsertMessages.notify || 0),
+      },
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+};
+
+export async function handlePingCommand({ sock, remoteJid, messageInfo, expirationMessage }) {
+  try {
+    const startedAt = Date.now();
+    const systemMetrics = getSystemMetrics();
+    let metricsSummary = null;
+    let metricsOk = false;
+    let metricsError = null;
+
+    try {
+      metricsSummary = await fetchMetricsSnapshot();
+      metricsOk = true;
+    } catch (error) {
+      metricsError = error.message;
+      logger.warn('Falha ao buscar métricas Prometheus para /ping.', { error: error.message });
+    }
+
+    const text = buildPingMessage({
+      systemMetrics,
+      metricsSummary,
+      metricsOk,
+      metricsError,
+      latencyMs: Date.now() - startedAt,
+      generatedAt: new Date(),
+    });
+    await sendAndStore(sock, remoteJid, { text }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+  } catch (error) {
+    logger.error('Erro ao gerar status do sistema:', { error: error.message });
+    await sendAndStore(sock, remoteJid, { text: 'Erro ao obter informações do sistema.' }, { quoted: messageInfo, ephemeralExpiration: expirationMessage });
+  }
+}

package/app/modules/systemMetricsModule/systemMetricsAiHelpService.js

@@ -0,0 +1,14 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createModuleAiHelpWrapper } from '../../services/ai/moduleAiHelpWrapperFactory.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const systemMetricsAiHelpWrapper = createModuleAiHelpWrapper({
+  moduleKey: 'system_metrics',
+  moduleLabel: 'comandos de metricas',
+  envPrefix: 'SYSTEM_METRICS_AI_HELP',
+  moduleDirPath: __dirname,
+  moduleNameFallback: 'systemMetricsModule',
+});

package/app/modules/systemMetricsModule/systemMetricsConfigRuntime.js

@@ -0,0 +1,68 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { createModuleCommandConfigRuntime } from '../../services/ai/moduleCommandConfigRuntimeService.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CONFIG_PATH = path.join(__dirname, 'commandConfig.json');
+
+const DEFAULT_TEXTS = {
+  usage_header: '',
+};
+
+const runtime = createModuleCommandConfigRuntime({
+  configPath: CONFIG_PATH,
+  fallbackConfig: {
+    module: 'systemMetricsModule',
+    commands: [],
+    textos: DEFAULT_TEXTS,
+  },
+});
+
+const renderUsageMethod = (method, commandPrefix) => String(method || '').replaceAll('<prefix>', String(commandPrefix || '/'));
+
+const resolveUsageLines = (entry, variant) => {
+  if (!entry || typeof entry !== 'object') return [];
+
+  const usageMessages = entry?.mensagens_uso && typeof entry.mensagens_uso === 'object' ? entry.mensagens_uso : null;
+
+  if (usageMessages) {
+    const variantKey = typeof variant === 'string' ? variant.trim() : '';
+    const picked = (variantKey && usageMessages[variantKey]) || usageMessages.default || null;
+    if (Array.isArray(picked)) {
+      return picked.filter(Boolean).map((value) => String(value));
+    }
+    if (typeof picked === 'string' && picked.trim()) {
+      return [picked.trim()];
+    }
+  }
+
+  const methods = Array.isArray(entry?.metodos_de_uso) ? entry.metodos_de_uso : [];
+  return methods.filter(Boolean).map((value) => String(value));
+};
+
+export const getSystemMetricsModuleConfig = () => runtime.getModuleConfig();
+
+export const resolveSystemMetricsCommandName = (command) => runtime.resolveCommandName(command);
+export const getSystemMetricsCommandEntry = (command) => runtime.getCommandEntry(command);
+export const listEnabledSystemMetricsCommands = () => runtime.listEnabledCommands();
+
+export const getSystemMetricsTextConfig = () => {
+  const config = getSystemMetricsModuleConfig();
+  const raw = config?.textos && typeof config.textos === 'object' ? config.textos : {};
+  return {
+    ...DEFAULT_TEXTS,
+    ...raw,
+  };
+};
+
+export const getSystemMetricsUsageText = (command, { commandPrefix = '/', header, variant } = {}) => {
+  const entry = getSystemMetricsCommandEntry(command);
+  const methods = resolveUsageLines(entry, variant);
+  if (!methods.length) return '';
+
+  const prefixHeader = typeof header === 'string' ? header : getSystemMetricsTextConfig().usage_header || DEFAULT_TEXTS.usage_header;
+  const lines = methods.map((method) => renderUsageMethod(method, commandPrefix));
+  return prefixHeader ? [prefixHeader, ...lines].join('\n') : lines.join('\n');
+};

package/app/modules/tiktokModule/AGENT.md

@@ -0,0 +1,196 @@
+# TiktokModule Agent Guide
+
+Este arquivo e destinado a agentes de IA para gerar respostas no contexto dos comandos deste modulo.
+
+## Fonte de Verdade
+
+- arquivo_base: `app/modules/tiktokModule/commandConfig.json`
+- schema_version: `2.0.0`
+- module_enabled: `true`
+- generated_at: `2026-03-11T02:35:17.177Z`
+
+## Escopo do Modulo
+
+- module: `tiktokModule`
+- source_files:
+- tiktokCommand.js
+- total_commands: `1`
+- total_enabled_commands: `1`
+
+## Defaults Schema v2
+
+- inheritance_mode: deep_merge_with_command_overrides
+- compatibility_mode: legacy_and_v2_fields
+- legacy_field_aliases:
+- descricao: description
+- metodos_de_uso: usage
+- permissao_necessaria: permission
+- local_de_uso: contexts
+- informacoes_coletadas: collected_data
+- pre_condicoes: requirements
+- dependencias_externas: dependencies
+- efeitos_colaterais: side_effects
+- observabilidade: observability
+- privacidade: privacy
+- limite_uso_por_plano: plan_limits
+- argumentos: arguments
+- acesso: access
+- defaults.command:
+- enabled: true
+- category: midia
+- version: 1.0.0
+- stability: stable
+- deprecated: false
+- replaced_by: null
+- risk_level: medium
+- defaults.requirements (legacy view):
+- requer_grupo: nao
+- requer_admin: nao
+- requer_admin_principal: nao
+- requer_google_login: sim
+- requer_nsfw: nao
+- requer_midia: nao
+- requer_mensagem_respondida: nao
+
+## Protocolo de Resposta para IA
+
+- Passo 1: identificar comando pelo token apos o prefixo.
+- Passo 2: resolver alias para nome canonico usando campo `aliases`.
+- Passo 3: validar `enabled`, `pre_condicoes`, permissao e local de uso.
+- Passo 4: se houver erro de uso, responder com `mensagens_uso` (quando existir) ou `metodos_de_uso`.
+- Passo 5: seguir `respostas_padrao` como fallback de texto.
+- Passo 6: considerar `informacoes_coletadas`, `privacidade` e `observabilidade` ao elaborar resposta.
+
+## Regras de Seguranca para IA
+
+- A IA orienta, mas nao executa acao administrativa automaticamente.
+- Nao inventar comandos, subcomandos ou permissao fora do JSON.
+- Sempre informar onde pode usar (grupo/privado) e quem pode usar.
+- Em duvida de permissao, responder com orientacao conservadora.
+
+## Catalogo de Comandos
+
+### baixartiktok
+
+- id: tiktok.baixartiktok
+- aliases: tt, tiktok
+- enabled: true
+- categoria: midia
+- descricao: Baixa midia do TikTok sem marca d'agua.
+- permissao_necessaria: usuario comum
+- version: 1.0.0
+- stability: stable
+- deprecated: nao
+- risk_level: low
+- local_de_uso:
+- privado
+- grupo
+- metodos_de_uso:
+- <prefix>baixartiktok <url>
+- <prefix>tt <url1> <url2>
+- mensagens_uso (variantes):
+- default:
+- 🎬 _Baixartiktok Downloader_
+- Uso: _<prefix>baixartiktok <link1> [link2 ...]_
+- Exemplo: _<prefix>baixartiktok https://www.baixartiktok.com/@usuario/video/123_
+- subcomandos:
+- (nenhum)
+- argumentos:
+- urls | tipo: array | obrigatorio | validacao: 1 a 5 URLs do TikTok | default: null | posicao: 0
+- pre_condicoes:
+- requer_grupo: nao
+- requer_admin: nao
+- requer_admin_principal: nao
+- requer_google_login: sim
+- requer_nsfw: nao
+- requer_midia: nao
+- requer_mensagem_respondida: nao
+- rate_limit:
+- max: 5
+- janela_ms: null
+- escopo: por_execucao
+- acesso:
+- somente_premium: nao
+- planos_permitidos: comum, premium
+- limite_uso_por_plano:
+- comum: max=4, janela_ms=600000, escopo=usuario
+- premium: max=15, janela_ms=600000, escopo=usuario
+- informacoes_coletadas:
+- identificador do chat (remoteJid)
+- identificador do remetente (senderJid)
+- texto do comando e argumentos
+- contexto da mensagem (citacao e mencoes, quando existir)
+- URLs do TikTok extraidas do texto
+- metadados do post (autor, descricao, estatisticas)
+- tamanho dos arquivos para enforce de limite
+- dependencias_externas:
+- serviço extractor de TikTok
+- efeitos_colaterais:
+- baixa mídia temporária
+- envia vídeo/imagens no chat
+- respostas_padrao:
+- success: Comando executado com sucesso.
+- usage_error: Formato de uso inválido. Consulte metodos_de_uso.
+- permission_error: Permissão insuficiente para executar este comando.
+- sucesso: Comando executado com sucesso.
+- erro_uso: Formato de uso inválido. Consulte metodos_de_uso.
+- erro_permissao: Permissão insuficiente para executar este comando.
+- mensagens_sistema:
+- (nao informado)
+- limites_operacionais:
+- (nao informado)
+- opcoes:
+- toggle_on_off_status.type: toggle
+- toggle_on_off_status.allowed_actions: on, off, status
+- toggle_on_off_status.action_argument: acao
+- add_remove_list.type: list_management
+- add_remove_list.allowed_actions: add, remove, list
+- add_remove_list.action_argument: acao
+- approve_reject.type: moderation_decision
+- approve_reject.allowed_actions: approve, reject
+- approve_reject.action_argument: acao
+- approve_reject.requires_targets: true
+- set_status_reset.type: configuration_window
+- set_status_reset.allowed_actions: set, status, reset
+- set_status_reset.action_argument: valor
+- observabilidade:
+- event_name: command.executed
+- analytics_event: whatsapp_command_tiktok
+- tags_log: whatsapp, command, tiktokModule, tiktok
+- nivel_log: info
+- privacidade:
+- dados_sensiveis:
+- chat_identifier
+- sender_identifier
+- command_content
+- retencao: standard_app_logs
+- base_legal: service_execution_and_legitimate_interest
+- docs:
+- summary: Baixa midia do TikTok sem marca d'agua.
+- usage_examples: <prefix>baixartiktok <url>, <prefix>tt <url1> <url2>
+- usage*variants.default: 🎬 \_Baixartiktok Downloader*, , Uso: _<prefix>baixartiktok <link1> [link2 ...]_, , Exemplo: _<prefix>baixartiktok https://www.baixartiktok.com/@usuario/video/123_
+- behavior:
+- type: argument_driven
+- allowed_actions: (nenhum)
+- limits:
+- usage_description: ate 5 URLs por comando e ate 80 MB por arquivo (padrao)
+- rate_limit.max: 5
+- rate_limit.janela_ms: null
+- rate_limit.escopo: por_execucao
+- access.somente_premium: false
+- access.planos_permitidos: comum, premium
+- plan_limits.comum.max: 4
+- plan_limits.comum.janela_ms: 600000
+- plan_limits.comum.escopo: usuario
+- plan_limits.premium.max: 15
+- plan_limits.premium.janela_ms: 600000
+- plan_limits.premium.escopo: usuario
+- discovery:
+- keywords: baixartiktok, tt, midia, privado, grupo
+- faq_queries: como usar baixartiktok, o que faz baixartiktok, comando baixartiktok
+- user_phrasings: quero usar baixartiktok, me ajuda com baixartiktok, baixa midia do baixartiktok
+- suggestion_priority: 100
+- handler:
+- file: tiktokCommand.js
+- method: handleTikTokCommand
+- command_case: baixartiktok