@omnizap-system/omnizap 2.5.12

package/app/modules/stickerPackModule/stickerWorkerPipelineRuntime.js

@@ -0,0 +1,242 @@
+import logger from '#logger';
+import { setQueueDepth } from '../../observability/metrics.js';
+import { isFeatureEnabled } from '../../services/infra/featureFlagService.js';
+import { runStickerClassificationCycle } from './stickerClassificationBackgroundRuntime.js';
+import { runStickerAutoPackByTagsCycle } from './stickerAutoPackByTagsRuntime.js';
+import { claimWorkerTask, completeWorkerTask, countWorkerTasksByStatus, enqueueWorkerTask, failWorkerTask, hasPendingWorkerTask } from './stickerWorkerTaskQueueRepository.js';
+
+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;
+};
+
+const PIPELINE_ENABLED = parseEnvBool(process.env.STICKER_WORKER_PIPELINE_ENABLED, false);
+const STARTUP_DELAY_MS = Math.max(1_000, Number(process.env.STICKER_WORKER_PIPELINE_STARTUP_DELAY_MS) || 12_000);
+const SCHEDULER_INTERVAL_MS = Math.max(2_000, Number(process.env.STICKER_WORKER_PIPELINE_SCHEDULER_INTERVAL_MS) || 15_000);
+const POLLER_INTERVAL_MS = Math.max(1_000, Number(process.env.STICKER_WORKER_PIPELINE_POLLER_INTERVAL_MS) || 4_000);
+const WORKER_RETRY_DELAY_SECONDS = Math.max(5, Math.min(3600, Number(process.env.STICKER_WORKER_PIPELINE_RETRY_DELAY_SECONDS) || 45));
+const INLINE_POLLER_ENABLED = parseEnvBool(process.env.STICKER_WORKER_PIPELINE_INLINE_POLLER_ENABLED, true);
+const INLINE_POLLER_FORCE_ENABLED = parseEnvBool(process.env.STICKER_WORKER_PIPELINE_INLINE_POLLER_FORCE_ENABLED, false);
+const INLINE_POLLER_LOOP_ACTIVE = INLINE_POLLER_ENABLED || INLINE_POLLER_FORCE_ENABLED;
+
+const TASK_CADENCE_MS = {
+  classification_cycle: Math.max(10_000, Number(process.env.STICKER_WORKER_CLASSIFICATION_CADENCE_MS) || 120_000),
+  curation_cycle: Math.max(15_000, Number(process.env.STICKER_WORKER_CURATION_CADENCE_MS) || 180_000),
+  rebuild_cycle: Math.max(15_000, Number(process.env.STICKER_WORKER_REBUILD_CADENCE_MS) || 240_000),
+};
+
+const TASK_PRIORITY = {
+  classification_cycle: 70,
+  curation_cycle: 55,
+  rebuild_cycle: 50,
+};
+const PIPELINE_PROCESS_COHORT_KEY = String(process.env.STICKER_WORKER_PIPELINE_COHORT_KEY || process.env.HOSTNAME || process.pid).trim() || 'pipeline';
+
+let startupHandle = null;
+let schedulerHandle = null;
+let pollerHandle = null;
+let runningPoll = false;
+let taskQueueAvailable = true;
+const nextScheduleByTask = new Map();
+
+const taskHandlers = {
+  classification_cycle: async () => runStickerClassificationCycle({ processPending: true, processReprocess: true }),
+  curation_cycle: async () => runStickerAutoPackByTagsCycle({ enableAdditions: true, enableRebuild: false }),
+  rebuild_cycle: async () => runStickerAutoPackByTagsCycle({ enableAdditions: false, enableRebuild: true }),
+};
+
+const refreshQueueDepthMetrics = async () => {
+  if (!taskQueueAvailable) return;
+  const [pending, processing, failed] = await Promise.all([countWorkerTasksByStatus('pending'), countWorkerTasksByStatus('processing'), countWorkerTasksByStatus('failed')]);
+  setQueueDepth('sticker_worker_tasks_pending', pending);
+  setQueueDepth('sticker_worker_tasks_processing', processing);
+  setQueueDepth('sticker_worker_tasks_failed', failed);
+};
+
+const canRunInlinePoller = async () => {
+  if (!INLINE_POLLER_ENABLED) return false;
+  if (INLINE_POLLER_FORCE_ENABLED) return true;
+  const dedicatedWorkersEnabled = await isFeatureEnabled('enable_worker_dedicated_processes', {
+    fallback: false,
+    subjectKey: `pipeline:inline_poller:${PIPELINE_PROCESS_COHORT_KEY}`,
+  });
+  return !dedicatedWorkersEnabled;
+};
+
+const scheduleTaskIfNeeded = async (taskType) => {
+  if (!taskQueueAvailable) return;
+  const cadence = TASK_CADENCE_MS[taskType];
+  if (!cadence) return;
+
+  const now = Date.now();
+  const nextDueAt = nextScheduleByTask.get(taskType) || 0;
+  if (now < nextDueAt) return;
+
+  const hasPending = await hasPendingWorkerTask(taskType);
+  if (hasPending) {
+    nextScheduleByTask.set(taskType, now + Math.floor(cadence / 2));
+    return;
+  }
+
+  await enqueueWorkerTask({
+    taskType,
+    payload: { scheduled_by: 'sticker_worker_pipeline' },
+    priority: TASK_PRIORITY[taskType] || 50,
+    idempotencyKey: `pipeline:${taskType}:${Math.floor(now / cadence)}`,
+  });
+  nextScheduleByTask.set(taskType, now + cadence);
+};
+
+const schedulerTick = async () => {
+  if (!PIPELINE_ENABLED) return;
+
+  try {
+    await Promise.all([scheduleTaskIfNeeded('classification_cycle'), scheduleTaskIfNeeded('curation_cycle'), scheduleTaskIfNeeded('rebuild_cycle')]);
+    await refreshQueueDepthMetrics();
+  } catch (error) {
+    if (error?.code === 'ER_NO_SUCH_TABLE') {
+      taskQueueAvailable = false;
+      logger.warn('Fila do pipeline de workers indisponivel (migração pendente).', {
+        action: 'sticker_worker_pipeline_queue_unavailable',
+      });
+      return;
+    }
+    throw error;
+  }
+};
+
+const processSingleTaskType = async (taskType) => {
+  if (!taskQueueAvailable) return false;
+  const task = await claimWorkerTask({ taskType });
+  if (!task) return false;
+
+  try {
+    const handler = taskHandlers[taskType];
+    if (typeof handler !== 'function') {
+      throw new Error(`handler_not_found:${taskType}`);
+    }
+
+    await handler(task.payload || {});
+    await completeWorkerTask(task.id);
+
+    logger.debug('Task de worker concluída.', {
+      action: 'sticker_worker_task_completed',
+      task_type: taskType,
+      task_id: task.id,
+      attempts: task.attempts,
+    });
+    return true;
+  } catch (error) {
+    await failWorkerTask(task.id, {
+      error: error?.message || 'worker_task_failed',
+      retryDelaySeconds: WORKER_RETRY_DELAY_SECONDS,
+    });
+
+    logger.warn('Task de worker falhou.', {
+      action: 'sticker_worker_task_failed',
+      task_type: taskType,
+      task_id: task.id,
+      attempts: task.attempts,
+      error: error?.message,
+    });
+    return true;
+  }
+};
+
+const pollerTick = async () => {
+  if (runningPoll || !PIPELINE_ENABLED) return;
+  runningPoll = true;
+
+  try {
+    if (!(await canRunInlinePoller())) return;
+
+    let progressed = false;
+
+    progressed = (await processSingleTaskType('classification_cycle')) || progressed;
+    progressed = (await processSingleTaskType('curation_cycle')) || progressed;
+    progressed = (await processSingleTaskType('rebuild_cycle')) || progressed;
+
+    if (progressed) {
+      await refreshQueueDepthMetrics();
+    }
+  } catch (error) {
+    if (error?.code === 'ER_NO_SUCH_TABLE') {
+      taskQueueAvailable = false;
+      logger.warn('Fila do pipeline de workers indisponivel durante o poll.', {
+        action: 'sticker_worker_pipeline_queue_unavailable_poll',
+      });
+    } else {
+      logger.error('Falha no poller do pipeline de workers.', {
+        action: 'sticker_worker_pipeline_poll_failed',
+        error: error?.message,
+      });
+    }
+  } finally {
+    runningPoll = false;
+  }
+};
+
+export const startStickerWorkerPipeline = () => {
+  if (!PIPELINE_ENABLED) {
+    logger.info('Pipeline de workers de sticker desabilitado.', {
+      action: 'sticker_worker_pipeline_disabled',
+    });
+    return;
+  }
+
+  if (startupHandle || schedulerHandle || pollerHandle) return;
+
+  logger.info('Iniciando pipeline de workers de sticker.', {
+    action: 'sticker_worker_pipeline_start',
+    startup_delay_ms: STARTUP_DELAY_MS,
+    scheduler_interval_ms: SCHEDULER_INTERVAL_MS,
+    poller_interval_ms: POLLER_INTERVAL_MS,
+    inline_poller_enabled: INLINE_POLLER_ENABLED,
+    inline_poller_loop_active: INLINE_POLLER_LOOP_ACTIVE,
+    cadence_ms: TASK_CADENCE_MS,
+  });
+
+  startupHandle = setTimeout(() => {
+    startupHandle = null;
+
+    void schedulerTick();
+    if (INLINE_POLLER_LOOP_ACTIVE) {
+      void pollerTick();
+    }
+
+    schedulerHandle = setInterval(() => {
+      void schedulerTick();
+    }, SCHEDULER_INTERVAL_MS);
+
+    if (INLINE_POLLER_LOOP_ACTIVE) {
+      pollerHandle = setInterval(() => {
+        void pollerTick();
+      }, POLLER_INTERVAL_MS);
+    }
+
+    if (typeof schedulerHandle.unref === 'function') schedulerHandle.unref();
+    if (typeof pollerHandle?.unref === 'function') pollerHandle.unref();
+  }, STARTUP_DELAY_MS);
+
+  if (typeof startupHandle.unref === 'function') startupHandle.unref();
+};
+
+export const stopStickerWorkerPipeline = () => {
+  if (startupHandle) {
+    clearTimeout(startupHandle);
+    startupHandle = null;
+  }
+  if (schedulerHandle) {
+    clearInterval(schedulerHandle);
+    schedulerHandle = null;
+  }
+  if (pollerHandle) {
+    clearInterval(pollerHandle);
+    pollerHandle = null;
+  }
+};
+
+export const isStickerWorkerPipelineEnabled = () => PIPELINE_ENABLED;

package/app/modules/stickerPackModule/stickerWorkerTaskQueueRepository.js

@@ -0,0 +1,242 @@
+import { randomUUID } from 'node:crypto';
+
+import { executeQuery, TABLES } from '../../../database/index.js';
+
+const normalizeTaskType = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  if (['classification_cycle', 'curation_cycle', 'rebuild_cycle'].includes(normalized)) return normalized;
+  return null;
+};
+
+const normalizeStatus = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  if (['pending', 'processing', 'completed', 'failed'].includes(normalized)) return normalized;
+  return null;
+};
+
+const clampInt = (value, fallback, min, max) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(numeric)));
+};
+
+const CLAIM_LOCK_TIMEOUT_SECONDS = clampInt(process.env.STICKER_WORKER_TASK_LOCK_TIMEOUT_SECONDS, 15 * 60, 30, 24 * 60 * 60);
+
+const normalizeIdempotencyKey = (value) =>
+  String(value || '')
+    .trim()
+    .replace(/[^a-zA-Z0-9_:-]/g, '')
+    .slice(0, 180);
+
+const parseJson = (value, fallback = null) => {
+  if (value === null || value === undefined) return fallback;
+  if (typeof value === 'object') return value;
+  if (Buffer.isBuffer(value)) {
+    try {
+      return JSON.parse(value.toString('utf8'));
+    } catch {
+      return fallback;
+    }
+  }
+
+  if (typeof value === 'string') {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return fallback;
+    }
+  }
+
+  return fallback;
+};
+
+const normalizeRow = (row) => {
+  if (!row) return null;
+  return {
+    id: Number(row.id),
+    task_type: row.task_type,
+    payload: parseJson(row.payload, {}),
+    idempotency_key: row.idempotency_key || null,
+    priority: Number(row.priority || 0),
+    scheduled_at: row.scheduled_at || null,
+    status: row.status,
+    attempts: Number(row.attempts || 0),
+    max_attempts: Number(row.max_attempts || 0),
+    worker_token: row.worker_token || null,
+    last_error: row.last_error || null,
+    locked_at: row.locked_at || null,
+    processed_at: row.processed_at || null,
+    created_at: row.created_at || null,
+    updated_at: row.updated_at || null,
+  };
+};
+
+export async function enqueueWorkerTask({ taskType, payload = {}, priority = 50, scheduledAt = null, maxAttempts = 5, idempotencyKey = '' }, connection = null) {
+  const normalizedTaskType = normalizeTaskType(taskType);
+  if (!normalizedTaskType) return false;
+
+  const safePriority = clampInt(priority, 50, 1, 100);
+  const safeMaxAttempts = clampInt(maxAttempts, 5, 1, 20);
+  const safeScheduledAt = scheduledAt ? new Date(scheduledAt) : null;
+  const scheduledValue = safeScheduledAt && Number.isFinite(safeScheduledAt.valueOf()) ? safeScheduledAt : null;
+  const normalizedIdempotencyKey = normalizeIdempotencyKey(idempotencyKey) || null;
+
+  await executeQuery(
+    `INSERT INTO ${TABLES.STICKER_WORKER_TASK_QUEUE}
+      (task_type, idempotency_key, payload, priority, scheduled_at, status, attempts, max_attempts)
+     VALUES (?, ?, ?, ?, COALESCE(?, UTC_TIMESTAMP()), 'pending', 0, ?)
+     ON DUPLICATE KEY UPDATE
+      payload = IF(status IN ('pending', 'failed'), VALUES(payload), payload),
+      priority = GREATEST(priority, VALUES(priority)),
+      scheduled_at = LEAST(scheduled_at, VALUES(scheduled_at)),
+      status = IF(status = 'failed' AND attempts < max_attempts, 'pending', status),
+      updated_at = UTC_TIMESTAMP()`,
+    [normalizedTaskType, normalizedIdempotencyKey, JSON.stringify(payload || {}), safePriority, scheduledValue, safeMaxAttempts],
+    connection,
+  );
+  return true;
+}
+
+export async function hasPendingWorkerTask(taskType, connection = null) {
+  const normalizedTaskType = normalizeTaskType(taskType);
+  if (!normalizedTaskType) return false;
+
+  const rows = await executeQuery(
+    `SELECT id
+     FROM ${TABLES.STICKER_WORKER_TASK_QUEUE}
+     WHERE task_type = ?
+       AND (
+         status IN ('pending', 'processing')
+         OR (status = 'failed' AND attempts < max_attempts)
+       )
+     LIMIT 1`,
+    [normalizedTaskType],
+    connection,
+  );
+  return rows.length > 0;
+}
+
+export async function claimWorkerTask({ taskType, allowRetryFailed = true } = {}, connection = null) {
+  const normalizedTaskType = normalizeTaskType(taskType);
+  if (!normalizedTaskType) return null;
+
+  const workerToken = randomUUID();
+  const statusClause = allowRetryFailed
+    ? `(status = 'pending'
+      OR (status = 'failed' AND attempts < max_attempts)
+      OR (status = 'processing' AND locked_at <= (UTC_TIMESTAMP() - INTERVAL ${CLAIM_LOCK_TIMEOUT_SECONDS} SECOND)))`
+    : `(status = 'pending'
+      OR (status = 'processing' AND locked_at <= (UTC_TIMESTAMP() - INTERVAL ${CLAIM_LOCK_TIMEOUT_SECONDS} SECOND)))`;
+
+  await executeQuery(
+    `UPDATE ${TABLES.STICKER_WORKER_TASK_QUEUE}
+     SET status = 'processing',
+         worker_token = ?,
+         locked_at = UTC_TIMESTAMP(),
+         attempts = attempts + 1,
+         updated_at = UTC_TIMESTAMP()
+     WHERE id = (
+       SELECT id FROM (
+         SELECT id
+         FROM ${TABLES.STICKER_WORKER_TASK_QUEUE}
+         WHERE task_type = ?
+           AND ${statusClause}
+           AND scheduled_at <= UTC_TIMESTAMP()
+         ORDER BY priority DESC, scheduled_at ASC, id ASC
+         LIMIT 1
+       ) pick
+     )`,
+    [workerToken, normalizedTaskType],
+    connection,
+  );
+
+  const rows = await executeQuery(
+    `SELECT *
+     FROM ${TABLES.STICKER_WORKER_TASK_QUEUE}
+     WHERE worker_token = ?
+       AND status = 'processing'
+     ORDER BY id DESC
+     LIMIT 1`,
+    [workerToken],
+    connection,
+  );
+
+  return normalizeRow(rows?.[0] || null);
+}
+
+export async function completeWorkerTask(taskId, connection = null) {
+  if (!taskId) return false;
+  await executeQuery(
+    `UPDATE ${TABLES.STICKER_WORKER_TASK_QUEUE}
+     SET status = 'completed',
+         processed_at = UTC_TIMESTAMP(),
+         worker_token = NULL,
+         locked_at = NULL,
+         last_error = NULL,
+         updated_at = UTC_TIMESTAMP()
+     WHERE id = ?`,
+    [taskId],
+    connection,
+  );
+  return true;
+}
+
+export async function failWorkerTask(taskId, { error = null, retryDelaySeconds = 0 } = {}, connection = null) {
+  if (!taskId) return false;
+  const safeDelay = clampInt(retryDelaySeconds, 0, 0, 86400 * 7);
+  const message =
+    String(error || '')
+      .trim()
+      .slice(0, 255) || null;
+
+  await executeQuery(
+    `UPDATE ${TABLES.STICKER_WORKER_TASK_QUEUE}
+     SET status = IF(attempts >= max_attempts, 'failed', 'pending'),
+         worker_token = NULL,
+         locked_at = NULL,
+         last_error = ?,
+         scheduled_at = IF(attempts >= max_attempts, scheduled_at, UTC_TIMESTAMP() + INTERVAL ${safeDelay} SECOND),
+         updated_at = UTC_TIMESTAMP(),
+         processed_at = IF(attempts >= max_attempts, UTC_TIMESTAMP(), processed_at)
+     WHERE id = ?`,
+    [message, taskId],
+    connection,
+  );
+
+  await executeQuery(
+    `INSERT INTO ${TABLES.STICKER_WORKER_TASK_DLQ}
+      (task_id, task_type, payload, idempotency_key, attempts, max_attempts, priority, last_error)
+     SELECT id, task_type, payload, idempotency_key, attempts, max_attempts, priority, last_error
+       FROM ${TABLES.STICKER_WORKER_TASK_QUEUE}
+      WHERE id = ?
+        AND status = 'failed'
+     ON DUPLICATE KEY UPDATE
+      attempts = VALUES(attempts),
+      max_attempts = VALUES(max_attempts),
+      priority = VALUES(priority),
+      last_error = VALUES(last_error),
+      failed_at = CURRENT_TIMESTAMP`,
+    [taskId],
+    connection,
+  ).catch(() => null);
+
+  return true;
+}
+
+export async function countWorkerTasksByStatus(status = 'pending', connection = null) {
+  const normalizedStatus = normalizeStatus(status);
+  if (!normalizedStatus) return 0;
+
+  const rows = await executeQuery(
+    `SELECT COUNT(*) AS total
+     FROM ${TABLES.STICKER_WORKER_TASK_QUEUE}
+     WHERE status = ?`,
+    [normalizedStatus],
+    connection,
+  );
+  return Number(rows?.[0]?.total || 0);
+}

package/app/modules/systemMetricsModule/AGENT.md

@@ -0,0 +1,193 @@
+# SystemMetricsModule 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/systemMetricsModule/commandConfig.json`
+- schema_version: `2.0.0`
+- module_enabled: `true`
+- generated_at: `2026-03-11T02:35:17.177Z`
+
+## Escopo do Modulo
+
+- module: `systemMetricsModule`
+- source_files:
+- pingCommand.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: sistema
+- 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
+
+### statusbot
+
+- id: systemmetrics.statusbot
+- aliases: ping
+- enabled: true
+- categoria: sistema
+- descricao: Exibe latencia e estado de saude do servidor.
+- permissao_necessaria: usuario comum
+- version: 1.0.0
+- stability: stable
+- deprecated: nao
+- risk_level: low
+- local_de_uso:
+- privado
+- grupo
+- metodos_de_uso:
+- <prefix>statusbot
+- mensagens_uso (variantes):
+- default:
+- <prefix>statusbot
+- subcomandos:
+- (nenhum)
+- argumentos:
+- (nenhum)
+- 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: null
+- janela_ms: null
+- escopo: sem_rate_limit_explicito
+- acesso:
+- somente_premium: nao
+- planos_permitidos: comum, premium
+- limite_uso_por_plano:
+- comum: max=40, janela_ms=60000, escopo=usuario
+- premium: max=160, janela_ms=60000, 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)
+- metricas do sistema operacional (cpu, memoria, uptime)
+- metricas avancadas do endpoint Prometheus (quando disponivel)
+- dependencias_externas:
+- coleta local de métricas
+- endpoint Prometheus (opcional)
+- efeitos_colaterais:
+- consulta estado do servidor
+- envia diagnóstico 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_ping
+- tags_log: whatsapp, command, systemMetricsModule, ping
+- 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: Exibe latencia e estado de saude do servidor.
+- usage_examples: <prefix>statusbot
+- usage_variants.default: <prefix>statusbot
+- behavior:
+- type: simple_action
+- allowed_actions: (nenhum)
+- limits:
+- usage_description: sem limite especifico
+- rate_limit.max: null
+- rate_limit.janela_ms: null
+- rate_limit.escopo: sem_rate_limit_explicito
+- access.somente_premium: false
+- access.planos_permitidos: comum, premium
+- plan_limits.comum.max: 40
+- plan_limits.comum.janela_ms: 60000
+- plan_limits.comum.escopo: usuario
+- plan_limits.premium.max: 160
+- plan_limits.premium.janela_ms: 60000
+- plan_limits.premium.escopo: usuario
+- discovery:
+- keywords: statusbot, sistema, privado, grupo
+- faq_queries: como usar statusbot, o que faz statusbot, comando statusbot
+- user_phrasings: quero usar statusbot, me ajuda com statusbot, exibe latencia e estado
+- suggestion_priority: 100
+- handler:
+- file: pingCommand.js
+- method: handlePingCommand
+- command_case: statusbot