@omnizap-system/omnizap 2.5.12

package/scripts/sticker-catalog-loadtest.mjs

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+import http from 'node:http';
+import https from 'node:https';
+import { performance } from 'node:perf_hooks';
+import fs from 'node:fs/promises';
+import { URL } from 'node:url';
+
+const DEFAULT_BASE_URL = process.env.STICKER_LOADTEST_BASE_URL || 'http://127.0.0.1:9102';
+const DEFAULT_PATHS = ['/api/sticker-packs?limit=24&offset=0&sort=popular', '/api/sticker-packs/stats', '/api/sticker-packs/creators?limit=25'];
+const DEFAULT_DURATION_SECONDS = 30;
+const DEFAULT_CONCURRENCY = 20;
+const DEFAULT_TIMEOUT_MS = 12_000;
+const DEFAULT_HTTP_SLO_MS = Number(process.env.HTTP_SLO_TARGET_MS || 750);
+
+const parseCliArgs = (argv) => {
+  const args = new Map();
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token.startsWith('--')) continue;
+    const next = argv[i + 1];
+    if (!next || next.startsWith('--')) {
+      args.set(token, true);
+      continue;
+    }
+    args.set(token, next);
+    i += 1;
+  }
+  return args;
+};
+
+const args = parseCliArgs(process.argv.slice(2));
+const baseUrl = String(args.get('--base-url') || DEFAULT_BASE_URL)
+  .trim()
+  .replace(/\/+$/, '');
+const durationSeconds = Math.max(5, Number(args.get('--duration-seconds') || DEFAULT_DURATION_SECONDS));
+const concurrency = Math.max(1, Number(args.get('--concurrency') || DEFAULT_CONCURRENCY));
+const timeoutMs = Math.max(1000, Number(args.get('--timeout-ms') || DEFAULT_TIMEOUT_MS));
+const outFile = String(args.get('--out') || '').trim();
+const sloMs = Math.max(50, Number(args.get('--slo-ms') || DEFAULT_HTTP_SLO_MS));
+const paths = String(args.get('--paths') || '')
+  .split(',')
+  .map((entry) => entry.trim())
+  .filter(Boolean);
+const requestPaths = paths.length ? paths : DEFAULT_PATHS;
+
+const url = new URL(baseUrl);
+const isHttps = url.protocol === 'https:';
+const requestClient = isHttps ? https : http;
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const quantile = (sortedValues, q) => {
+  if (!sortedValues.length) return 0;
+  const index = Math.max(0, Math.min(sortedValues.length - 1, Math.floor((sortedValues.length - 1) * q)));
+  return sortedValues[index];
+};
+
+const runRequest = (pathName) =>
+  new Promise((resolve) => {
+    const started = performance.now();
+    const req = requestClient.request(
+      {
+        protocol: url.protocol,
+        hostname: url.hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: pathName,
+        method: 'GET',
+        timeout: timeoutMs,
+        headers: {
+          Connection: 'keep-alive',
+          Accept: 'application/json',
+          'X-Viewer-Key': 'loadtest',
+          'X-Session-Key': 'loadtest',
+          'User-Agent': 'omnizap-sticker-loadtest/1.0',
+        },
+      },
+      (res) => {
+        res.resume();
+        res.on('end', () => {
+          const durationMs = performance.now() - started;
+          resolve({
+            ok: res.statusCode >= 200 && res.statusCode < 500,
+            statusCode: Number(res.statusCode || 0),
+            durationMs,
+            pathName,
+          });
+        });
+      },
+    );
+
+    req.on('timeout', () => {
+      req.destroy(new Error('timeout'));
+    });
+    req.on('error', (error) => {
+      const durationMs = performance.now() - started;
+      resolve({
+        ok: false,
+        statusCode: 0,
+        durationMs,
+        pathName,
+        error: error?.message || 'request_error',
+      });
+    });
+    req.end();
+  });
+
+const runWorker = async ({ deadlineMs, workerIndex, stats }) => {
+  let requestIndex = workerIndex % requestPaths.length;
+  while (Date.now() < deadlineMs) {
+    const pathName = requestPaths[requestIndex % requestPaths.length];
+    requestIndex += 1;
+
+    const result = await runRequest(pathName);
+    stats.total += 1;
+    stats.latencies.push(result.durationMs);
+    stats.byStatus.set(result.statusCode, Number(stats.byStatus.get(result.statusCode) || 0) + 1);
+    if (result.ok) {
+      stats.success += 1;
+    } else {
+      stats.errors += 1;
+      stats.lastErrors.push({
+        path: pathName,
+        status_code: result.statusCode,
+        error: result.error || null,
+      });
+      if (stats.lastErrors.length > 10) stats.lastErrors.shift();
+    }
+  }
+};
+
+const main = async () => {
+  const startedAt = Date.now();
+  const deadlineMs = startedAt + durationSeconds * 1000;
+  const stats = {
+    total: 0,
+    success: 0,
+    errors: 0,
+    latencies: [],
+    byStatus: new Map(),
+    lastErrors: [],
+  };
+
+  console.log(`[loadtest] base_url=${baseUrl}`);
+  console.log(`[loadtest] duration_seconds=${durationSeconds} concurrency=${concurrency} paths=${requestPaths.join(',')}`);
+  await sleep(250);
+
+  await Promise.all(
+    Array.from({ length: concurrency }).map((_, index) =>
+      runWorker({
+        deadlineMs,
+        workerIndex: index,
+        stats,
+      }),
+    ),
+  );
+
+  const elapsedSeconds = Math.max(0.001, (Date.now() - startedAt) / 1000);
+  const sortedLatencies = [...stats.latencies].sort((a, b) => a - b);
+  const p50 = quantile(sortedLatencies, 0.5);
+  const p90 = quantile(sortedLatencies, 0.9);
+  const p95 = quantile(sortedLatencies, 0.95);
+  const p99 = quantile(sortedLatencies, 0.99);
+  const throughputRps = stats.total / elapsedSeconds;
+  const errorRate = stats.total > 0 ? stats.errors / stats.total : 1;
+
+  const summary = {
+    started_at: new Date(startedAt).toISOString(),
+    ended_at: new Date().toISOString(),
+    base_url: baseUrl,
+    duration_seconds: Number(elapsedSeconds.toFixed(3)),
+    concurrency,
+    paths: requestPaths,
+    requests_total: stats.total,
+    requests_success: stats.success,
+    requests_error: stats.errors,
+    error_rate: Number(errorRate.toFixed(6)),
+    throughput_rps: Number(throughputRps.toFixed(3)),
+    latency_ms: {
+      p50: Number(p50.toFixed(2)),
+      p90: Number(p90.toFixed(2)),
+      p95: Number(p95.toFixed(2)),
+      p99: Number(p99.toFixed(2)),
+      max: Number((sortedLatencies[sortedLatencies.length - 1] || 0).toFixed(2)),
+    },
+    by_status: Object.fromEntries(stats.byStatus.entries()),
+    slo: {
+      target_ms: sloMs,
+      p95_within_target: p95 <= sloMs,
+    },
+    sample_errors: stats.lastErrors,
+  };
+
+  console.log(JSON.stringify(summary, null, 2));
+  if (outFile) {
+    await fs.writeFile(outFile, `${JSON.stringify(summary, null, 2)}\n`, 'utf8');
+    console.log(`[loadtest] report_written=${outFile}`);
+  }
+
+  if (summary.requests_total <= 0) {
+    process.exitCode = 2;
+    return;
+  }
+  if (summary.slo.p95_within_target && summary.error_rate <= 0.02) return;
+  process.exitCode = 1;
+};
+
+main().catch((error) => {
+  console.error('[loadtest] fatal_error', error?.message || error);
+  process.exitCode = 2;
+});

package/scripts/sticker-worker-task.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+
+import logger from '#logger';
+import initializeDatabase from '../database/init.js';
+import { closePool } from '../database/index.js';
+import { isSupportedStickerWorkerTaskType, startDedicatedStickerWorker } from '../app/modules/stickerPackModule/stickerDedicatedTaskWorkerRuntime.js';
+
+const parseCliArgs = (argv = []) => {
+  const args = new Map();
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) continue;
+    const next = argv[index + 1];
+    if (!next || next.startsWith('--')) {
+      args.set(token, true);
+      continue;
+    }
+    args.set(token, next);
+    index += 1;
+  }
+  return args;
+};
+
+const args = parseCliArgs(process.argv.slice(2));
+const workerTaskType = String(args.get('--task-type') || process.env.STICKER_WORKER_TASK_TYPE || '')
+  .trim()
+  .toLowerCase();
+
+if (!isSupportedStickerWorkerTaskType(workerTaskType)) {
+  logger.error('Tipo de task inválido para worker dedicado.', {
+    action: 'sticker_worker_task_invalid_type',
+    task_type: workerTaskType || null,
+  });
+  process.exit(1);
+}
+
+let shuttingDown = false;
+let workerHandle = null;
+
+const shutdown = async (signal, error = null) => {
+  if (shuttingDown) return;
+  shuttingDown = true;
+
+  logger.warn('Encerrando worker dedicado de sticker.', {
+    action: 'sticker_worker_task_shutdown',
+    signal,
+    task_type: workerTaskType,
+    error: error?.message || null,
+  });
+
+  try {
+    workerHandle?.stop?.();
+  } catch (stopError) {
+    logger.warn('Falha ao encerrar loop do worker dedicado.', {
+      action: 'sticker_worker_task_stop_failed',
+      task_type: workerTaskType,
+      error: stopError?.message,
+    });
+  }
+
+  try {
+    await closePool();
+  } catch (poolError) {
+    logger.warn('Falha ao encerrar pool MySQL no worker dedicado.', {
+      action: 'sticker_worker_task_pool_close_failed',
+      task_type: workerTaskType,
+      error: poolError?.message,
+    });
+  }
+
+  process.exit(error ? 1 : 0);
+};
+
+process.on('SIGINT', () => {
+  void shutdown('SIGINT');
+});
+
+process.on('SIGTERM', () => {
+  void shutdown('SIGTERM');
+});
+
+process.on('uncaughtException', (error) => {
+  logger.error('Exceção não capturada no worker dedicado de sticker.', {
+    action: 'sticker_worker_task_uncaught_exception',
+    task_type: workerTaskType,
+    error: error?.message,
+    stack: error?.stack,
+  });
+  void shutdown('uncaughtException', error);
+});
+
+process.on('unhandledRejection', (reason) => {
+  const message = reason instanceof Error ? reason.message : String(reason || '');
+  logger.error('Promise rejeitada sem tratamento no worker dedicado de sticker.', {
+    action: 'sticker_worker_task_unhandled_rejection',
+    task_type: workerTaskType,
+    error: message,
+  });
+  void shutdown('unhandledRejection', reason instanceof Error ? reason : new Error(message));
+});
+
+const start = async () => {
+  await initializeDatabase();
+  workerHandle = startDedicatedStickerWorker({
+    taskType: workerTaskType,
+    label: `process:${process.pid}`,
+  });
+};
+
+start().catch((error) => {
+  logger.error('Falha ao inicializar worker dedicado de sticker.', {
+    action: 'sticker_worker_task_start_failed',
+    task_type: workerTaskType,
+    error: error?.message,
+    stack: error?.stack,
+  });
+  void shutdown('startup_error', error);
+});

package/scripts/sync-readme-snapshot.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import dotenv from 'dotenv';
+
+dotenv.config({ path: '.env' });
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '..');
+
+const START_MARKER = '<!-- README_SNAPSHOT:START -->';
+const END_MARKER = '<!-- README_SNAPSHOT:END -->';
+const DEFAULT_README_TARGET = 'README.md';
+const DEFAULT_TIMEOUT_MS = 15000;
+const DEFAULT_MAX_BYTES = 500_000;
+
+const escapeRegExp = (value) => String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const isLocalHostname = (hostname) => ['localhost', '127.0.0.1', '::1'].includes(String(hostname || '').toLowerCase());
+const toPositiveInt = (value, fallback, min = 1) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < min) return fallback;
+  return Math.floor(parsed);
+};
+const toBool = (value, fallback = false) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  return ['1', 'true', 'yes', 'on'].includes(String(value).trim().toLowerCase());
+};
+const ensurePathWithinRoot = (rootPath, targetPath) => {
+  const relative = path.relative(rootPath, targetPath);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) {
+    throw new Error(`Caminho fora do projeto não permitido: ${targetPath}`);
+  }
+};
+
+const readmePath = path.resolve(projectRoot, process.env.README_SNAPSHOT_TARGET_PATH || DEFAULT_README_TARGET);
+ensurePathWithinRoot(projectRoot, readmePath);
+
+const siteOrigin = String(process.env.SITE_ORIGIN || 'https://omnizap.shop')
+  .trim()
+  .replace(/\/+$/, '');
+const sourceUrlRaw = String(process.env.README_SNAPSHOT_SOURCE_URL || `${siteOrigin}/api/readme-markdown`).trim();
+const timeoutMs = Math.max(1000, toPositiveInt(process.env.README_SNAPSHOT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, 1000));
+const maxBytes = Math.max(1024, toPositiveInt(process.env.README_SNAPSHOT_MAX_BYTES, DEFAULT_MAX_BYTES, 1024));
+const allowExternalSource = toBool(process.env.README_SNAPSHOT_ALLOW_EXTERNAL_SOURCE, false);
+
+const resolveSourceUrl = (candidateUrl, trustedSiteOrigin, allowExternal) => {
+  let trusted;
+  let source;
+  try {
+    trusted = new URL(trustedSiteOrigin);
+    source = new URL(candidateUrl);
+  } catch {
+    throw new Error('SITE_ORIGIN ou README_SNAPSHOT_SOURCE_URL inválido.');
+  }
+
+  if (source.protocol !== 'https:' && !isLocalHostname(source.hostname)) {
+    throw new Error(`README_SNAPSHOT_SOURCE_URL deve usar HTTPS (ou localhost): ${source.origin}`);
+  }
+
+  if (!allowExternal && source.origin !== trusted.origin) {
+    throw new Error(`README_SNAPSHOT_SOURCE_URL fora do domínio confiável (${trusted.origin}). Defina README_SNAPSHOT_ALLOW_EXTERNAL_SOURCE=1 para liberar.`);
+  }
+
+  return source.toString();
+};
+
+const sourceUrl = resolveSourceUrl(sourceUrlRaw, siteOrigin, allowExternalSource);
+
+const fetchWithTimeout = async (url, timeout, maxContentBytes) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: { 'User-Agent': 'omnizap-readme-sync/1.0' },
+      signal: controller.signal,
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} ao buscar snapshot`);
+    }
+    const content = String(await response.text()).trim();
+    if (!content) {
+      throw new Error('Snapshot markdown vazio');
+    }
+    const contentBytes = Buffer.byteLength(content, 'utf8');
+    if (contentBytes > maxContentBytes) {
+      throw new Error(`Snapshot excede limite de ${maxContentBytes} bytes.`);
+    }
+    if (content.includes(START_MARKER) || content.includes(END_MARKER)) {
+      throw new Error('Snapshot não pode conter os marcadores START/END.');
+    }
+    return content;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+
+const syncReadmeSnapshot = async () => {
+  const markdown = await fetchWithTimeout(sourceUrl, timeoutMs, maxBytes);
+  const readme = await fs.readFile(readmePath, 'utf8');
+
+  const blockRegex = new RegExp(`${escapeRegExp(START_MARKER)}[\\s\\S]*?${escapeRegExp(END_MARKER)}`, 'm');
+  if (!blockRegex.test(readme)) {
+    throw new Error(`Marcadores não encontrados em ${path.relative(projectRoot, readmePath)} (${START_MARKER} ... ${END_MARKER})`);
+  }
+
+  const replacement = `${START_MARKER}\n${markdown}\n${END_MARKER}`;
+  const nextReadme = readme.replace(blockRegex, replacement);
+
+  if (nextReadme === readme) {
+    console.log('[readme-sync] Snapshot já está atualizado.');
+    return;
+  }
+
+  const tempPath = `${readmePath}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    // lgtm[js/http-to-file-access]
+    await fs.writeFile(tempPath, nextReadme, 'utf8');
+    await fs.rename(tempPath, readmePath);
+  } catch (error) {
+    await fs.rm(tempPath, { force: true }).catch(() => {});
+    throw error;
+  }
+  console.log(`[readme-sync] README atualizado com snapshot de ${sourceUrl}`);
+};
+
+syncReadmeSnapshot().catch((error) => {
+  console.error(`[readme-sync] Falha: ${error?.message || error}`);
+  process.exit(1);
+});

package/scripts/validate-command-config-schema.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+
+const parseCliArgs = (argv = []) => {
+  const args = new Map();
+  const positional = [];
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) {
+      positional.push(token);
+      continue;
+    }
+
+    const next = argv[index + 1];
+    if (!next || next.startsWith('--')) {
+      args.set(token, true);
+      continue;
+    }
+
+    if (token === '--file') {
+      const current = args.get(token);
+      if (Array.isArray(current)) {
+        current.push(next);
+      } else if (typeof current === 'string') {
+        args.set(token, [current, next]);
+      } else {
+        args.set(token, next);
+      }
+      index += 1;
+      continue;
+    }
+
+    args.set(token, next);
+    index += 1;
+  }
+
+  return { args, positional };
+};
+
+const asArray = (value) => {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  return [value];
+};
+
+const discoverDefaultConfigFiles = () => {
+  const modulesRoot = path.join(process.cwd(), 'app', 'modules');
+  let moduleEntries = [];
+  try {
+    moduleEntries = fs.readdirSync(modulesRoot, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  return moduleEntries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(modulesRoot, entry.name, 'commandConfig.json'))
+    .filter((configPath) => fs.existsSync(configPath))
+    .sort((left, right) => left.localeCompare(right));
+};
+
+const formatAjvError = (error) => {
+  const instancePath = error?.instancePath || '/';
+  const message = error?.message || 'invalid';
+  const keyword = error?.keyword ? ` [${error.keyword}]` : '';
+  return `${instancePath}${keyword}: ${message}`;
+};
+
+const { args, positional } = parseCliArgs(process.argv.slice(2));
+const schemaPath = path.resolve(String(args.get('--schema') || path.join(process.cwd(), 'schemas', 'command-config.schema.json')));
+const explicitFiles = [...asArray(args.get('--file')), ...positional].map((file) => path.resolve(String(file)));
+const targetFiles = explicitFiles.length ? explicitFiles : discoverDefaultConfigFiles();
+
+if (!fs.existsSync(schemaPath)) {
+  console.error(`[command-config-schema] schema nao encontrado: ${schemaPath}`);
+  console.error('Gere antes com: npm run command-config:schema:generate');
+  process.exit(1);
+}
+
+if (!targetFiles.length) {
+  console.error('[command-config-schema] nenhum arquivo alvo encontrado para validacao');
+  process.exit(1);
+}
+
+const rawSchema = fs.readFileSync(schemaPath, 'utf8');
+const schema = JSON.parse(rawSchema);
+
+const ajv = new Ajv2020({ allErrors: true, strict: false });
+const validate = ajv.compile(schema);
+
+let hasErrors = false;
+
+for (const targetFile of targetFiles) {
+  if (!fs.existsSync(targetFile)) {
+    hasErrors = true;
+    console.error(`\n✖ ${path.relative(process.cwd(), targetFile)} (arquivo nao encontrado)`);
+    continue;
+  }
+
+  let payload = null;
+  try {
+    payload = JSON.parse(fs.readFileSync(targetFile, 'utf8'));
+  } catch (error) {
+    hasErrors = true;
+    console.error(`\n✖ ${path.relative(process.cwd(), targetFile)} (json invalido: ${error?.message || error})`);
+    continue;
+  }
+
+  const ok = validate(payload);
+  if (ok) {
+    console.log(`✔ ${path.relative(process.cwd(), targetFile)}`);
+    continue;
+  }
+
+  hasErrors = true;
+  console.error(`\n✖ ${path.relative(process.cwd(), targetFile)}`);
+  for (const error of validate.errors || []) {
+    console.error(`  - ${formatAjvError(error)}`);
+  }
+}
+
+if (hasErrors) {
+  process.exit(1);
+}
+
+console.log(`\n[command-config-schema] ok (${targetFiles.length} arquivo(s))`);

package/scripts/validate-command-configs.mjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+import { formatCommandConfigValidationReport, validateAllCommandConfigs } from '../app/services/ai/commandConfigValidationService.js';
+
+const report = validateAllCommandConfigs();
+const printable = formatCommandConfigValidationReport(report, { maxErrors: 80 });
+
+if (!report.ok) {
+  console.error('[command-config-validation] falhou');
+  console.error(printable);
+  process.exit(1);
+}
+
+console.log('[command-config-validation] ok');
+console.log(printable);