@omnizap-system/omnizap 2.5.12

package/app/utils/http/getImageBufferModule.js

@@ -0,0 +1,18 @@
+import https from 'node:https';
+
+const getImageBuffer = (url) =>
+  new Promise((resolve, reject) => {
+    https
+      .get(url, (response) => {
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to get image, status code: ${response.statusCode}`));
+          return;
+        }
+        const chunks = [];
+        response.on('data', (chunk) => chunks.push(chunk));
+        response.on('end', () => resolve(Buffer.concat(chunks)));
+      })
+      .on('error', (err) => reject(err));
+  });
+
+export default getImageBuffer;

package/app/utils/json/jsonSanitizer.js

@@ -0,0 +1,113 @@
+/**
+ * Sanitiza caracteres Unicode invalidos para JSON.
+ * Substitui surrogates "soltos" (sem par valido) por U+FFFD.
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+export const sanitizeUnicodeString = (value) => {
+  if (typeof value !== 'string' || value.length === 0) {
+    return value;
+  }
+
+  if (!/[\uD800-\uDFFF]/.test(value)) {
+    return value;
+  }
+
+  let normalized = '';
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const nextCode = value.charCodeAt(i + 1);
+      if (nextCode >= 0xdc00 && nextCode <= 0xdfff) {
+        normalized += value[i] + value[i + 1];
+        i += 1;
+      } else {
+        normalized += '\uFFFD';
+      }
+      continue;
+    }
+
+    if (code >= 0xdc00 && code <= 0xdfff) {
+      normalized += '\uFFFD';
+      continue;
+    }
+
+    normalized += value[i];
+  }
+
+  return normalized;
+};
+
+/**
+ * Cria replacer para JSON.stringify com suporte a:
+ * - strings com surrogate invalido
+ * - referencias circulares
+ * - bigint
+ * - numeros nao finitos
+ *
+ * @returns {(key:string, value:any)=>any}
+ */
+const createSafeJsonReplacer = () => {
+  const seen = new WeakSet();
+
+  return (_, value) => {
+    if (typeof value === 'string') {
+      return sanitizeUnicodeString(value);
+    }
+
+    if (typeof value === 'bigint') {
+      return value.toString();
+    }
+
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+      return null;
+    }
+
+    if (value instanceof Date) {
+      return Number.isNaN(value.getTime()) ? null : value.toISOString();
+    }
+
+    if (value && typeof value === 'object') {
+      if (seen.has(value)) {
+        return '[Circular]';
+      }
+      seen.add(value);
+    }
+
+    return value;
+  };
+};
+
+/**
+ * Converte qualquer valor para texto JSON seguro para colunas JSON do MySQL.
+ * - Objetos/arrays sao serializados com saneamento
+ * - Strings sao saneadas; se nao forem JSON valido, viram JSON string
+ *
+ * @param {*} value
+ * @returns {string|null}
+ */
+export const toSafeJsonColumnValue = (value) => {
+  if (value === undefined || value === null) {
+    return null;
+  }
+
+  if (typeof value === 'string') {
+    const sanitized = sanitizeUnicodeString(value);
+    try {
+      const parsed = JSON.parse(sanitized);
+      const normalizedJson = JSON.stringify(parsed, createSafeJsonReplacer());
+      return normalizedJson === undefined ? null : normalizedJson;
+    } catch {
+      return JSON.stringify(sanitized);
+    }
+  }
+
+  try {
+    const json = JSON.stringify(value, createSafeJsonReplacer());
+    return json === undefined ? null : json;
+  } catch {
+    return JSON.stringify('[Unserializable]');
+  }
+};

package/app/utils/json/jsonSanitizer.test.js

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { sanitizeUnicodeString, toSafeJsonColumnValue } from './jsonSanitizer.js';
+
+test('sanitizeUnicodeString mantem pares surrogate validos', () => {
+  const input = 'emoji \uD83D\uDE00 ok';
+  assert.equal(sanitizeUnicodeString(input), input);
+});
+
+test('sanitizeUnicodeString substitui surrogates invalidos por U+FFFD', () => {
+  const input = `invalido \ud800 meio \udc00 fim`;
+  const output = sanitizeUnicodeString(input);
+  assert.equal(output, 'invalido \uFFFD meio \uFFFD fim');
+});
+
+test('toSafeJsonColumnValue sanitiza objeto com surrogate invalido', () => {
+  const raw = {
+    text: `abc\ud800def`,
+    nested: { note: `x\udc00y` },
+  };
+
+  const json = toSafeJsonColumnValue(raw);
+  assert.equal(typeof json, 'string');
+
+  const parsed = JSON.parse(json);
+  assert.equal(parsed.text, 'abc\uFFFDdef');
+  assert.equal(parsed.nested.note, 'x\uFFFDy');
+});
+
+test('toSafeJsonColumnValue sanitiza JSON string com escape de surrogate invalido', () => {
+  const raw = '{"text":"\\ud800"}';
+  const json = toSafeJsonColumnValue(raw);
+  const parsed = JSON.parse(json);
+  assert.equal(parsed.text, '\uFFFD');
+});
+
+test('toSafeJsonColumnValue transforma texto simples em JSON string valido', () => {
+  const json = toSafeJsonColumnValue('texto simples');
+  assert.equal(json, '"texto simples"');
+});

package/app/utils/systemMetrics/systemMetricsModule.js

@@ -0,0 +1,88 @@
+import os from 'node:os';
+import process from 'node:process';
+
+const formatBytes = (bytes) => {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+};
+
+const formatDuration = (totalSeconds) => {
+  const total = Math.max(0, Math.floor(totalSeconds));
+  const days = Math.floor(total / 86400);
+  const hours = Math.floor((total % 86400) / 3600);
+  const minutes = Math.floor((total % 3600) / 60);
+  const seconds = total % 60;
+
+  const time = [hours, minutes, seconds].map((value) => String(value).padStart(2, '0')).join(':');
+  return days > 0 ? `${days}d ${time}` : time;
+};
+
+export const getSystemMetrics = () => {
+  const totalMemory = os.totalmem();
+  const freeMemory = os.freemem();
+  const usedMemory = totalMemory - freeMemory;
+  const memoryUsagePercentage = (usedMemory / totalMemory) * 100;
+
+  const cpus = os.cpus();
+  const totalCpus = cpus.length;
+  let totalIdle = 0;
+  let totalTick = 0;
+
+  for (const cpu of cpus) {
+    for (const type in cpu.times) {
+      totalTick += cpu.times[type];
+    }
+    totalIdle += cpu.times.idle;
+  }
+
+  const cpuUsagePercentage = 100 - (totalIdle / totalTick) * 100;
+
+  const processUptimeSeconds = process.uptime();
+  const systemUptimeSeconds = os.uptime();
+  const uptime = formatDuration(processUptimeSeconds);
+  const systemUptime = formatDuration(systemUptimeSeconds);
+  const loadAverage = os.loadavg();
+  const cpuSpeedAverage = totalCpus > 0 ? Math.round(cpus.reduce((sum, cpu) => sum + (cpu.speed || 0), 0) / totalCpus) : 0;
+  const memoryUsage = process.memoryUsage();
+
+  return {
+    usoCpuPercentual: parseFloat(cpuUsagePercentage.toFixed(2)),
+    cargaMedia: loadAverage.map((value) => parseFloat(value.toFixed(2))),
+    totalCpus,
+    cpuModelo: cpus[0]?.model || 'Desconhecido',
+    cpuVelocidadeMediaMHz: cpuSpeedAverage,
+
+    usoMemoriaPercentual: parseFloat(memoryUsagePercentage.toFixed(2)),
+    memoriaTotal: formatBytes(totalMemory),
+    memoriaLivre: formatBytes(freeMemory),
+    memoriaUsada: formatBytes(usedMemory),
+    memoriaProcesso: {
+      rss: formatBytes(memoryUsage.rss),
+      heapTotal: formatBytes(memoryUsage.heapTotal),
+      heapUsado: formatBytes(memoryUsage.heapUsed),
+      external: formatBytes(memoryUsage.external),
+      arrayBuffers: formatBytes(memoryUsage.arrayBuffers || 0),
+    },
+
+    uptime,
+    uptimeSistema: systemUptime,
+    uptimeSegundos: Math.floor(processUptimeSeconds),
+    uptimeSistemaSegundos: Math.floor(systemUptimeSeconds),
+    plataforma: os.platform(),
+    arquitetura: os.arch(),
+    hostname: os.hostname(),
+    tipo: os.type(),
+    release: os.release(),
+    versaoNode: process.version,
+    nodeEnv: process.env.NODE_ENV || 'development',
+    pid: process.pid,
+    ppid: process.ppid,
+    cpus: cpus.map((cpu) => ({
+      modelo: cpu.model,
+      velocidade: cpu.speed,
+    })),
+  };
+};