@omnizap-system/omnizap 2.6.1 → 2.6.2

package/server/routes/observability/grafanaProxyRouter.js

@@ -0,0 +1,254 @@
+import http from 'node:http';
+import https from 'node:https';
+import { URL } from 'node:url';
+
+import logger from '#logger';
+
+const HOP_BY_HOP_HEADERS = new Set(['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade']);
+
+const DEFAULT_GRAFANA_PROXY_BASE_PATH = '/api/grafana';
+const DEFAULT_GRAFANA_PROXY_LEGACY_BASE_PATH = '/grafana';
+const DEFAULT_GRAFANA_PROXY_TIMEOUT_MS = 15000;
+
+const normalizeBasePath = (value, fallback) => {
+  const raw = String(value || '').trim() || fallback;
+  const withLeadingSlash = raw.startsWith('/') ? raw : `/${raw}`;
+  const withoutTrailingSlash = withLeadingSlash.length > 1 && withLeadingSlash.endsWith('/') ? withLeadingSlash.slice(0, -1) : withLeadingSlash;
+  return withoutTrailingSlash || fallback;
+};
+
+const startsWithPath = (pathname, prefix) => {
+  if (!pathname || !prefix) return false;
+  if (pathname === prefix) return true;
+  return pathname.startsWith(`${prefix}/`);
+};
+
+const parseEnvBool = (value, fallback = true) => {
+  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 parseEnvNumber = (value, fallback) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.round(parsed) : fallback;
+};
+
+const normalizeTargetUrl = (rawUrl) => {
+  const raw = String(rawUrl || '').trim();
+  if (!raw) return null;
+  try {
+    const parsed = new URL(raw);
+    if (!['http:', 'https:'].includes(parsed.protocol)) return null;
+    parsed.search = '';
+    parsed.hash = '';
+    parsed.pathname = String(parsed.pathname || '/').replace(/\/+$/, '') || '/';
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+
+const normalizeHeaderValue = (value) => {
+  if (Array.isArray(value))
+    return value
+      .map((item) => String(item || '').trim())
+      .filter(Boolean)
+      .join(', ');
+  return String(value || '').trim();
+};
+
+const getDefaultTargetUrl = () => {
+  const port = parseEnvNumber(process.env.GRAFANA_PORT, 3003);
+  return `http://127.0.0.1:${port}`;
+};
+
+const joinUrlPath = (leftPath, rightPath) => {
+  const left = String(leftPath || '').replace(/\/+$/, '');
+  const right = String(rightPath || '').replace(/^\/+/, '');
+  if (!left) return `/${right}`.replace(/\/{2,}/g, '/');
+  if (!right) return left.startsWith('/') ? left : `/${left}`;
+  const joined = `${left}/${right}`.replace(/\/{2,}/g, '/');
+  return joined.startsWith('/') ? joined : `/${joined}`;
+};
+
+const buildUpstreamPath = ({ pathname, search = '', matchedBasePath, upstreamBasePath, canonicalBasePath }) => {
+  const suffix = pathname === matchedBasePath ? '' : pathname.slice(matchedBasePath.length);
+  const normalizedSuffix = suffix ? (suffix.startsWith('/') ? suffix : `/${suffix}`) : '';
+  const canonicalPath = `${canonicalBasePath}${normalizedSuffix}` || canonicalBasePath;
+  const path = joinUrlPath(upstreamBasePath === '/' ? '' : upstreamBasePath, canonicalPath);
+  return `${path}${search || ''}`;
+};
+
+const getMatchedBasePath = (pathname, config) => {
+  if (!config?.enabled) return null;
+  if (startsWithPath(pathname, config.basePath)) return config.basePath;
+  if (config.legacyBasePath && startsWithPath(pathname, config.legacyBasePath)) return config.legacyBasePath;
+  return null;
+};
+
+const copyResponseHeaders = (res, upstreamHeaders = {}) => {
+  for (const [name, value] of Object.entries(upstreamHeaders)) {
+    if (value === undefined) continue;
+    const lower = String(name || '').toLowerCase();
+    if (!lower || HOP_BY_HOP_HEADERS.has(lower)) continue;
+    res.setHeader(name, value);
+  }
+};
+
+const buildUpstreamHeaders = (req, { matchedBasePath, target }) => {
+  const headers = {};
+  for (const [name, value] of Object.entries(req.headers || {})) {
+    if (value === undefined) continue;
+    const lower = String(name || '').toLowerCase();
+    if (!lower || lower === 'host' || HOP_BY_HOP_HEADERS.has(lower)) continue;
+    headers[lower] = value;
+  }
+
+  const incomingForwardedFor = normalizeHeaderValue(req.headers?.['x-forwarded-for']);
+  const remoteAddress = String(req.socket?.remoteAddress || '').trim();
+  const forwardedFor = [incomingForwardedFor, remoteAddress].filter(Boolean).join(', ');
+  if (forwardedFor) headers['x-forwarded-for'] = forwardedFor;
+
+  const forwardedProto = normalizeHeaderValue(req.headers?.['x-forwarded-proto']) || (req.socket?.encrypted ? 'https' : 'http');
+  headers['x-forwarded-proto'] = forwardedProto;
+
+  const incomingHost = normalizeHeaderValue(req.headers?.host);
+  const forwardedHost = normalizeHeaderValue(req.headers?.['x-forwarded-host']) || incomingHost;
+  if (forwardedHost) headers['x-forwarded-host'] = forwardedHost;
+
+  headers['x-forwarded-prefix'] = matchedBasePath;
+  headers.host = incomingHost || target.host;
+  return headers;
+};
+
+const pipeToUpstream = ({ req, res, target, targetPathWithQuery, timeoutMs, headers }) =>
+  new Promise((resolve, reject) => {
+    let settled = false;
+    const finalize = (error = null) => {
+      if (settled) return;
+      settled = true;
+      if (error) reject(error);
+      else resolve();
+    };
+
+    const transport = target.protocol === 'https:' ? https : http;
+    const upstreamReq = transport.request(
+      {
+        protocol: target.protocol,
+        hostname: target.hostname,
+        port: target.port || (target.protocol === 'https:' ? 443 : 80),
+        method: req.method,
+        path: targetPathWithQuery,
+        headers,
+      },
+      (upstreamRes) => {
+        res.statusCode = Number(upstreamRes.statusCode) || 502;
+        if (upstreamRes.statusMessage) res.statusMessage = upstreamRes.statusMessage;
+        copyResponseHeaders(res, upstreamRes.headers);
+
+        if (String(req.method || '').toUpperCase() === 'HEAD') {
+          upstreamRes.resume();
+          upstreamRes.once('end', () => {
+            if (!res.writableEnded) res.end();
+            finalize();
+          });
+          upstreamRes.once('error', finalize);
+          return;
+        }
+
+        upstreamRes.once('error', finalize);
+        res.once('error', finalize);
+        upstreamRes.pipe(res);
+        upstreamRes.once('end', finalize);
+      },
+    );
+
+    upstreamReq.setTimeout(timeoutMs, () => {
+      upstreamReq.destroy(new Error(`Grafana proxy timeout (${timeoutMs}ms)`));
+    });
+
+    upstreamReq.once('error', finalize);
+    req.once('error', (error) => upstreamReq.destroy(error));
+    req.once('aborted', () => upstreamReq.destroy(new Error('Client aborted request')));
+
+    if (['GET', 'HEAD'].includes(String(req.method || '').toUpperCase())) {
+      upstreamReq.end();
+      return;
+    }
+
+    req.pipe(upstreamReq);
+  });
+
+export const getGrafanaProxyRouterConfig = () => {
+  const enabled = parseEnvBool(process.env.GRAFANA_PROXY_ENABLED, true);
+  const basePath = normalizeBasePath(process.env.GRAFANA_PROXY_BASE_PATH, DEFAULT_GRAFANA_PROXY_BASE_PATH);
+  const legacyBasePath = normalizeBasePath(process.env.GRAFANA_PROXY_LEGACY_BASE_PATH, DEFAULT_GRAFANA_PROXY_LEGACY_BASE_PATH);
+  const timeoutMs = parseEnvNumber(process.env.GRAFANA_PROXY_TIMEOUT_MS, DEFAULT_GRAFANA_PROXY_TIMEOUT_MS);
+  const target = normalizeTargetUrl(process.env.GRAFANA_PROXY_TARGET_URL || getDefaultTargetUrl());
+
+  return {
+    enabled: Boolean(enabled && target),
+    basePath,
+    legacyBasePath,
+    timeoutMs,
+    target,
+  };
+};
+
+export const shouldHandleGrafanaProxyPath = (pathname, config = null) => Boolean(getMatchedBasePath(pathname, config || getGrafanaProxyRouterConfig()));
+
+const sendProxyError = (req, res, message) => {
+  if (res.writableEnded) return;
+  res.statusCode = 502;
+  res.setHeader('Content-Type', 'application/json; charset=utf-8');
+  if (req.method === 'HEAD') {
+    res.end();
+    return;
+  }
+  res.end(JSON.stringify({ error: message }));
+};
+
+export const maybeHandleGrafanaProxyRequest = async (req, res, { pathname, url, config = null } = {}) => {
+  const resolvedConfig = config || getGrafanaProxyRouterConfig();
+  const matchedBasePath = getMatchedBasePath(pathname, resolvedConfig);
+  if (!matchedBasePath) return false;
+
+  if (!resolvedConfig?.target) {
+    sendProxyError(req, res, 'Grafana proxy indisponivel.');
+    return true;
+  }
+
+  const targetPathWithQuery = buildUpstreamPath({
+    pathname,
+    search: url?.search || '',
+    matchedBasePath,
+    upstreamBasePath: resolvedConfig.target.pathname || '/',
+    canonicalBasePath: resolvedConfig.basePath,
+  });
+
+  try {
+    const headers = buildUpstreamHeaders(req, { matchedBasePath, target: resolvedConfig.target });
+    await pipeToUpstream({
+      req,
+      res,
+      target: resolvedConfig.target,
+      targetPathWithQuery,
+      timeoutMs: resolvedConfig.timeoutMs,
+      headers,
+    });
+  } catch (error) {
+    logger.warn('Falha ao encaminhar request para o Grafana.', {
+      action: 'grafana_proxy_failed',
+      path: pathname,
+      method: req.method,
+      target_path: targetPathWithQuery,
+      error: error?.message,
+    });
+    sendProxyError(req, res, 'Grafana indisponivel no momento.');
+  }
+
+  return true;
+};

package/server/routes/static/staticPageRouter.js

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 
 import logger from '#logger';
+import { buildWhatsappUrl, formatWhatsappDisplay, resolvePublicWhatsappNumber } from '../../utils/publicContact.js';
 
 const normalizeBasePath = (value, fallback) => {
   const raw = String(value || '').trim() || fallback;
@@ -21,6 +22,11 @@ const PUBLIC_PAGES_DIR = path.join(process.cwd(), 'public', 'pages');
 const SEO_ROUTE_PREFIX = '/seo/';
 const SEO_SLUG_REGEX = /^[a-z0-9-]+$/;
 const INDEX_FILE_SUFFIX = '/index.html';
+const LGPD_DEFAULT_TEXT = 'Olá, gostaria de exercer meus direitos de titular de dados (LGPD).';
+const SUPPORT_WHATSAPP_NUMBER = resolvePublicWhatsappNumber();
+const SUPPORT_WHATSAPP_URL = buildWhatsappUrl(SUPPORT_WHATSAPP_NUMBER);
+const SUPPORT_WHATSAPP_URL_LGPD = buildWhatsappUrl(SUPPORT_WHATSAPP_NUMBER, process.env.WHATSAPP_SUPPORT_LGPD_TEXT || LGPD_DEFAULT_TEXT);
+const SUPPORT_WHATSAPP_DISPLAY = formatWhatsappDisplay(SUPPORT_WHATSAPP_NUMBER);
 
 const STATIC_PAGE_ROUTE_TO_FILE = new Map(
   [
@@ -89,6 +95,26 @@ const sendJson = (req, res, statusCode, payload) => {
   res.end(body);
 };
 
+const injectStaticTemplateTokens = (html) => {
+  let rendered = String(html || '');
+  const replacements = {
+    __WHATSAPP_SUPPORT_NUMBER__: SUPPORT_WHATSAPP_NUMBER,
+    __WHATSAPP_SUPPORT_URL__: SUPPORT_WHATSAPP_URL,
+    __WHATSAPP_SUPPORT_URL_LGPD__: SUPPORT_WHATSAPP_URL_LGPD,
+    __WHATSAPP_SUPPORT_DISPLAY__: SUPPORT_WHATSAPP_DISPLAY,
+    __WHATSAPP_PUBLIC_CONTACT_NUMBER__: SUPPORT_WHATSAPP_NUMBER,
+    __WHATSAPP_PUBLIC_CONTACT_URL__: SUPPORT_WHATSAPP_URL,
+    __WHATSAPP_PUBLIC_CONTACT_URL_LGPD__: SUPPORT_WHATSAPP_URL_LGPD,
+    __WHATSAPP_PUBLIC_CONTACT_DISPLAY__: SUPPORT_WHATSAPP_DISPLAY,
+  };
+
+  for (const [token, value] of Object.entries(replacements)) {
+    rendered = rendered.replaceAll(token, String(value || ''));
+  }
+
+  return rendered;
+};
+
 export const shouldHandleStaticPagePath = (pathname) => Boolean(resolveStaticTemplateName(pathname));
 
 export const maybeHandleStaticPageRequest = async (req, res, { pathname } = {}) => {
@@ -116,7 +142,7 @@ export const maybeHandleStaticPageRequest = async (req, res, { pathname } = {})
   const templatePath = path.join(PUBLIC_PAGES_DIR, templateName);
   try {
     const html = await fs.readFile(templatePath, 'utf8');
-    sendHtml(req, res, html);
+    sendHtml(req, res, injectStaticTemplateTokens(html));
   } catch (error) {
     if (error?.code === 'ENOENT') {
       sendJson(req, res, 404, { error: 'Template da pagina nao encontrado.' });

package/server/utils/publicContact.js

@@ -0,0 +1,31 @@
+import { isLikelyWhatsAppPhone, normalizePhoneDigits, resolveSupportPhoneFromEnv } from '../../utils/whatsapp/contactEnv.js';
+
+const FALLBACK_WHATSAPP_SUPPORT_NUMBER = '5511999999999';
+
+export { normalizePhoneDigits };
+
+export const resolvePublicWhatsappNumber = ({ fallback = FALLBACK_WHATSAPP_SUPPORT_NUMBER } = {}) => resolveSupportPhoneFromEnv({ fallback });
+
+export const formatWhatsappDisplay = (value) => {
+  const digits = normalizePhoneDigits(value || '');
+  if (!isLikelyWhatsAppPhone(digits)) return '';
+
+  if (digits.startsWith('55') && digits.length === 12) {
+    return `+55 ${digits.slice(2, 4)} ${digits.slice(4, 8)}-${digits.slice(8)}`;
+  }
+
+  if (digits.startsWith('55') && digits.length === 13) {
+    return `+55 ${digits.slice(2, 4)} ${digits.slice(4, 9)}-${digits.slice(9)}`;
+  }
+
+  return `+${digits}`;
+};
+
+export const buildWhatsappUrl = (value, text = '') => {
+  const digits = normalizePhoneDigits(value || '');
+  if (!isLikelyWhatsAppPhone(digits)) return '';
+
+  const normalizedText = String(text || '').trim();
+  if (!normalizedText) return `https://wa.me/${digits}`;
+  return `https://wa.me/${digits}?text=${encodeURIComponent(normalizedText)}`;
+};

package/utils/whatsapp/contactEnv.js

@@ -0,0 +1,39 @@
+const MAX_PHONE_DIGITS = 20;
+const DEFAULT_FALLBACK_NUMBER = '5511999999999';
+
+const BOT_PHONE_ENV_KEYS = ['WHATSAPP_BOT_NUMBER', 'WHATSAPP_SUPPORT_NUMBER', 'BOT_NUMBER', 'BOT_PHONE_NUMBER', 'PHONE_NUMBER'];
+const SUPPORT_PHONE_ENV_KEYS = ['WHATSAPP_SUPPORT_NUMBER', 'WHATSAPP_ADMIN_NUMBER', 'WHATSAPP_PUBLIC_CONTACT_NUMBER', 'EMAIL_BRAND_SUPPORT_PHONE', 'OWNER_NUMBER'];
+const ADMIN_PHONE_ENV_KEYS = ['WHATSAPP_ADMIN_NUMBER', 'WHATSAPP_ADMIN_JID', 'USER_ADMIN', 'OWNER_NUMBER', 'WHATSAPP_SUPPORT_NUMBER', 'WHATSAPP_PUBLIC_CONTACT_NUMBER'];
+const ADMIN_IDENTITY_ENV_KEYS = ['WHATSAPP_ADMIN_JID', 'USER_ADMIN', 'WHATSAPP_ADMIN_NUMBER'];
+
+export const normalizePhoneDigits = (value, maxLength = MAX_PHONE_DIGITS) =>
+  String(value || '')
+    .replace(/\D+/g, '')
+    .slice(0, Math.max(1, Number(maxLength) || MAX_PHONE_DIGITS));
+
+export const isLikelyWhatsAppPhone = (value) => /^\d{10,15}$/.test(normalizePhoneDigits(value, 20));
+
+const resolvePhoneFromEnvKeys = (keys, { fallback = '' } = {}) => {
+  for (const envKey of keys) {
+    const digits = normalizePhoneDigits(process.env[envKey] || '');
+    if (isLikelyWhatsAppPhone(digits)) return digits;
+  }
+
+  const fallbackDigits = normalizePhoneDigits(fallback || '');
+  if (isLikelyWhatsAppPhone(fallbackDigits)) return fallbackDigits;
+  return '';
+};
+
+export const resolveBotPhoneFromEnv = ({ fallback = DEFAULT_FALLBACK_NUMBER } = {}) => resolvePhoneFromEnvKeys(BOT_PHONE_ENV_KEYS, { fallback });
+
+export const resolveSupportPhoneFromEnv = ({ fallback = DEFAULT_FALLBACK_NUMBER } = {}) => resolvePhoneFromEnvKeys(SUPPORT_PHONE_ENV_KEYS, { fallback });
+
+export const resolveAdminPhoneFromEnv = ({ fallback = DEFAULT_FALLBACK_NUMBER } = {}) => resolvePhoneFromEnvKeys(ADMIN_PHONE_ENV_KEYS, { fallback });
+
+export const resolveAdminIdentityRawFromEnv = ({ fallback = '' } = {}) => {
+  for (const envKey of ADMIN_IDENTITY_ENV_KEYS) {
+    const value = String(process.env[envKey] || '').trim();
+    if (value) return value;
+  }
+  return String(fallback || '').trim();
+};

package/vite.config.mjs

@@ -24,6 +24,7 @@ export default defineConfig({
       input: {
         'home-react': path.join(projectRoot, 'public', 'js', 'apps', 'homeReactApp.js'),
         'login-react': path.join(projectRoot, 'public', 'js', 'apps', 'loginReactApp.js'),
+        'user-password-reset-react': path.join(projectRoot, 'public', 'js', 'apps', 'userPasswordResetReactApp.js'),
         'user-react': path.join(projectRoot, 'public', 'js', 'apps', 'userReactApp.js'),
         'commands-react': path.join(projectRoot, 'public', 'js', 'apps', 'commandsReactApp.js'),
         'terms-react': path.join(projectRoot, 'public', 'js', 'apps', 'termsReactApp.js'),
@@ -31,7 +32,7 @@ export default defineConfig({
         'stickers-react': path.join(projectRoot, 'public', 'js', 'apps', 'stickersApp.js'),
         'create-pack-react': path.join(projectRoot, 'public', 'js', 'apps', 'createPackApp.js'),
         'stickers-admin': path.join(projectRoot, 'public', 'js', 'apps', 'stickersAdminApp.js'),
-        'user-systemadm': path.join(projectRoot, 'public', 'js', 'apps', 'userApp.js'),
+        'user-systemadm': path.join(projectRoot, 'public', 'js', 'apps', 'userSystemAdmReactApp.js'),
       },
       output: {
         format: 'es',

package/app/modules/playModule/local/installYtDlp.js

@@ -1,25 +0,0 @@
-import { installYtDlpBinary, DEFAULT_YTDLP_BINARY_PATH } from './ytDlpInstaller.js';
-import { fileURLToPath } from 'node:url';
-
-async function instalarYtDlp() {
-  console.log('📥 Iniciando instalação do yt-dlp...');
-  console.log('⬇️ Baixando yt-dlp (versão mais recente)...');
-
-  const caminhoBinario = await installYtDlpBinary({
-    binaryPath: DEFAULT_YTDLP_BINARY_PATH,
-  });
-
-  console.log('✅ yt-dlp instalado com sucesso!');
-  console.log(`📍 Caminho do binário: ${caminhoBinario}`);
-}
-
-const isDirectRun = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
-
-if (isDirectRun) {
-  instalarYtDlp().catch((erro) => {
-    console.error('❌ Erro ao instalar o yt-dlp:');
-    console.error(erro.message);
-  });
-}
-
-export { instalarYtDlp };

package/app/modules/playModule/local/ytDlpInstaller.js

@@ -1,28 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import YTDlpWrapImport from 'yt-dlp-wrap';
-
-const YTDlpWrap = YTDlpWrapImport?.default || YTDlpWrapImport;
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const DEFAULT_BIN_DIR = path.join(__dirname, 'bin');
-const DEFAULT_BINARY_NAME = os.platform() === 'win32' ? 'yt-dlp.exe' : 'yt-dlp';
-export const DEFAULT_YTDLP_BINARY_PATH = path.join(DEFAULT_BIN_DIR, DEFAULT_BINARY_NAME);
-
-export const installYtDlpBinary = async ({ binaryPath = DEFAULT_YTDLP_BINARY_PATH } = {}) => {
-  const targetPath = path.resolve(binaryPath);
-  const targetDir = path.dirname(targetPath);
-
-  await fs.promises.mkdir(targetDir, { recursive: true });
-  await YTDlpWrap.downloadFromGithub(targetPath, undefined, os.platform());
-
-  if (os.platform() !== 'win32') {
-    await fs.promises.chmod(targetPath, 0o755);
-  }
-
-  return targetPath;
-};