hightjs 0.2.53 → 0.3.0

package/dist/helpers.js

@@ -1,4 +1,20 @@
 "use strict";
+/*
+ * This file is part of the HightJS Project.
+ * Copyright (c) 2025 itsmuzin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -37,234 +53,157 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.app = app;
-// Helpers para integração com diferentes frameworks
-const index_1 = __importStar(require("./index"));
+// Imports Nativos do Node.js (movidos para o topo)
+const http_1 = __importDefault(require("http"));
 const os_1 = __importDefault(require("os"));
+const url_1 = require("url"); // API moderna, substitui 'querystring'
+// Helpers para integração com diferentes frameworks
+const index_1 = __importStar(require("./index")); // Importando o tipo
 const console_1 = __importStar(require("./api/console"));
+const https_1 = __importDefault(require("https")); // <-- ADICIONAR
+const fs_1 = __importDefault(require("fs")); // <-- ADICIONAR
+// --- Helpers ---
+/**
+ * Encontra o IP externo local (rede)
+ */
 function getLocalExternalIp() {
     const interfaces = os_1.default.networkInterfaces();
     for (const name of Object.keys(interfaces)) {
-        for (const iface of interfaces[name]) {
-            if (iface.family === 'IPv4' && !iface.internal) {
-                return iface.address;
+        const ifaceList = interfaces[name];
+        if (ifaceList) {
+            for (const iface of ifaceList) {
+                if (iface.family === 'IPv4' && !iface.internal) {
+                    return iface.address;
+                }
             }
         }
     }
-    return 'localhost';
+    return 'localhost'; // Fallback
 }
 const sendBox = (options) => {
     const isDev = options.dev ? "Rodando em modo de desenvolvimento" : null;
+    // 1. Verifica se o SSL está ativado (baseado na mesma lógica do initNativeServer)
+    const isSSL = options.ssl && options.ssl.key && options.ssl.cert;
+    const protocol = isSSL ? 'https' : 'http';
+    const localIp = getLocalExternalIp(); // Assume que getLocalExternalIp() existe
+    // 2. Monta as mensagens com o protocolo correto
     const messages = [
-        ` ${console_1.Colors.FgMagenta}●  ${console_1.Colors.Reset}Local: ${console_1.Colors.FgGreen}http://localhost:${options.port}${console_1.Colors.Reset}`,
-        ` ${console_1.Colors.FgMagenta}●  ${console_1.Colors.Reset}Rede: ${console_1.Colors.FgGreen}http://${getLocalExternalIp()}:${options.port}${console_1.Colors.Reset}`,
+        ` ${console_1.Colors.FgGray}┃${console_1.Colors.Reset} Local: ${console_1.Colors.FgGreen}${protocol}://localhost:${options.port}${console_1.Colors.Reset}`,
     ];
-    if (isDev) {
-        messages.push(` ${console_1.Colors.FgMagenta}●  ${console_1.Colors.Reset}${isDev}`);
-    }
-    console_1.default.box(messages.join("\n"), { title: "Acesse o HightJS em:" });
-};
-exports.default = app;
-function app(options = {}) {
-    const framework = options.framework || 'native'; // Mudando o padrão para 'native'
-    index_1.FrameworkAdapterFactory.setFramework(framework);
-    const hwebApp = (0, index_1.default)(options);
-    return {
-        ...hwebApp,
-        /**
-         * Integra com uma aplicação de qualquer framework (Express, Fastify, etc)
-         */
-        integrate: async (serverApp) => {
-            await hwebApp.prepare();
-            const handler = hwebApp.getRequestHandler();
-            if (framework === 'express') {
-                // Express integration
-                serverApp.use(handler);
-                hwebApp.setupWebSocket(serverApp);
-            }
-            else if (framework === 'fastify') {
-                // Fastify integration
-                await serverApp.register(async (fastify) => {
-                    fastify.all('*', handler);
-                });
-                hwebApp.setupWebSocket(serverApp);
-            }
-            else {
-                // Generic integration - assume Express-like
-                serverApp.use(handler);
-                hwebApp.setupWebSocket(serverApp);
-            }
-            hwebApp.executeInstrumentation();
-            return serverApp;
-        },
-        /**
-         * Inicia um servidor HightJS fechado (o usuário não tem acesso ao framework)
-         */
-        init: async () => {
-            console.log(`${console_1.Colors.FgMagenta}
-     _    _ _       _     _          _  _____ 
-    | |  | (_)     | |   | |        | |/ ____|
-    | |__| |_  __ _| |__ | |_       | | (___  
-    |  __  | |/ _\` | '_ \\| __|  _   | |\\___ \\ 
-    | |  | | | (_| | | | | |_  | |__| |____) |
-    |_|  |_|_|\\__, |_| |_|\\__|  \\____/|_____/ 
-               __/ |                          
-              |___/                           ${console_1.Colors.Reset}`);
-            const actualPort = options.port || 3000;
-            const actualHostname = options.hostname || "0.0.0.0";
-            if (framework === 'express') {
-                return await initExpressServer(hwebApp, options, actualPort, actualHostname);
-            }
-            else if (framework === 'fastify') {
-                return await initFastifyServer(hwebApp, options, actualPort, actualHostname);
-            }
-            else {
-                // Default to Native
-                return await initNativeServer(hwebApp, options, actualPort, actualHostname);
-            }
-        }
-    };
-}
-/**
- * Inicializa servidor Express fechado
- */
-async function initExpressServer(hwebApp, options, port, hostname) {
-    const msg = console_1.default.dynamicLine(`  ${console_1.Colors.FgCyan}●  ${console_1.Colors.Reset}Iniciando HightJS com Express...`);
-    const express = require('express');
-    const app = express();
-    // Middlewares básicos para Express
-    app.use(express.json());
-    app.use(express.urlencoded({ extended: true }));
-    // Cookie parser se disponível
-    try {
-        const cookieParser = require('cookie-parser');
-        app.use(cookieParser());
-    }
-    catch (e) {
-        console_1.default.error("Não foi possivel achar cookie-parser");
-    }
-    await hwebApp.prepare();
-    const handler = hwebApp.getRequestHandler();
-    app.use(handler);
-    const server = app.listen(port, hostname, () => {
-        sendBox({ ...options, port });
-        msg.end(`  ${console_1.Colors.FgCyan}●  ${console_1.Colors.Reset}Servidor Express iniciado (compatibilidade)`);
-    });
-    // Configura WebSocket para hot reload
-    hwebApp.setupWebSocket(server);
-    hwebApp.executeInstrumentation();
-    return server;
-}
-/**
- * Inicializa servidor Fastify fechado
- */
-async function initFastifyServer(hwebApp, options, port, hostname) {
-    const msg = console_1.default.dynamicLine(`  ${console_1.Colors.FgCyan}●  ${console_1.Colors.Reset}Iniciando HightJS com Fastify...`);
-    const fastify = require('fastify')({ logger: false });
-    // Registra plugins básicos para Fastify
-    try {
-        await fastify.register(require('@fastify/cookie'));
-    }
-    catch (e) {
-        console_1.default.error("Não foi possivel achar @fastify/cookie");
+    // Só adiciona a rede se o IP local for encontrado
+    if (localIp) {
+        messages.push(` ${console_1.Colors.FgGray}┃${console_1.Colors.Reset} Rede:  ${console_1.Colors.FgGreen}${protocol}://${localIp}:${options.port}${console_1.Colors.Reset}`);
     }
-    try {
-        await fastify.register(require('@fastify/formbody'));
+    if (isDev) {
+        messages.push(` ${console_1.Colors.FgGray}┃${console_1.Colors.Reset} ${isDev}`);
     }
-    catch (e) {
-        console_1.default.error("Não foi possivel achar @fastify/formbody");
+    // Adiciona aviso de redirecionamento se estiver em modo SSL
+    if (isSSL && options.ssl?.redirectPort) {
+        messages.push(` ${console_1.Colors.FgGray}┃${console_1.Colors.Reset} HTTP (porta ${options.ssl?.redirectPort}) está redirecionando para HTTPS.`);
     }
-    await hwebApp.prepare();
-    const handler = hwebApp.getRequestHandler();
-    // Registra o handler do hweb
-    await fastify.register(async (fastify) => {
-        fastify.all('*', handler);
-    });
-    hwebApp.setupWebSocket(fastify);
-    const address = await fastify.listen({ port, host: hostname });
-    sendBox({ ...options, port });
-    msg.end(`  ${console_1.Colors.FgCyan}●  ${console_1.Colors.Reset}Servidor Fastify iniciado (compatibilidade)`);
-    hwebApp.executeInstrumentation();
-    return fastify;
-}
+    console_1.default.box(messages.join("\n"), { title: "Acesse em:" });
+};
 /**
- * Inicializa servidor nativo do HightJS usando HTTP puro
+ * Middleware para parsing do body com proteções de segurança (versão melhorada).
+ * Rejeita a promise em caso de erro de parsing ou estouro de limite.
  */
-async function initNativeServer(hwebApp, options, port, hostname) {
-    const msg = console_1.default.dynamicLine(`  ${console_1.Colors.FgMagenta}⚡  ${console_1.Colors.Reset}${console_1.Colors.Bright}Iniciando HightJS em modo NATIVO${console_1.Colors.Reset}`);
-    const http = require('http');
-    const { parse: parseUrl } = require('url');
-    const { parse: parseQuery } = require('querystring');
-    await hwebApp.prepare();
-    const handler = hwebApp.getRequestHandler();
-    // Middleware para parsing do body com proteções de segurança
-    const parseBody = (req) => {
-        return new Promise((resolve, reject) => {
-            if (req.method === 'GET' || req.method === 'HEAD') {
+const parseBody = (req) => {
+    // Constantes para limites de segurança
+    const MAX_BODY_SIZE = 10 * 1024 * 1024; // 10MB limite total
+    const MAX_JSON_SIZE = 1 * 1024 * 1024; // 1MB limite para JSON
+    const BODY_TIMEOUT = 30000; // 30 segundos
+    return new Promise((resolve, reject) => {
+        if (req.method === 'GET' || req.method === 'HEAD') {
+            resolve(null);
+            return;
+        }
+        let body = '';
+        let totalSize = 0;
+        // Timeout para requisições lentas
+        const timeout = setTimeout(() => {
+            req.destroy();
+            reject(new Error('Request body timeout'));
+        }, BODY_TIMEOUT);
+        req.on('data', (chunk) => {
+            totalSize += chunk.length;
+            // Proteção contra DoS (Payload Too Large)
+            if (totalSize > MAX_BODY_SIZE) {
+                clearTimeout(timeout);
+                req.destroy();
+                reject(new Error('Request body too large'));
+                return;
+            }
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            clearTimeout(timeout);
+            if (!body) {
                 resolve(null);
                 return;
             }
-            let body = '';
-            let totalSize = 0;
-            const maxBodySize = 10 * 1024 * 1024; // 10MB limite
-            // Timeout para requisições que demoram muito
-            const timeout = setTimeout(() => {
-                req.destroy();
-                reject(new Error('Request timeout'));
-            }, 30000); // 30 segundos
-            req.on('data', (chunk) => {
-                totalSize += chunk.length;
-                // Proteção contra ataques de DoS por body muito grande
-                if (totalSize > maxBodySize) {
-                    clearTimeout(timeout);
-                    req.destroy();
-                    reject(new Error('Request body too large'));
-                    return;
-                }
-                body += chunk.toString();
-            });
-            req.on('end', () => {
-                clearTimeout(timeout);
-                try {
-                    const contentType = req.headers['content-type'] || '';
-                    if (contentType.includes('application/json')) {
-                        // Validação adicional para JSON
-                        if (body.length > 1024 * 1024) { // 1MB limite para JSON
-                            reject(new Error('JSON body too large'));
-                            return;
-                        }
-                        resolve(JSON.parse(body));
+            try {
+                const contentType = req.headers['content-type'] || '';
+                if (contentType.includes('application/json')) {
+                    if (body.length > MAX_JSON_SIZE) {
+                        reject(new Error('JSON body too large'));
+                        return;
                     }
-                    else if (contentType.includes('application/x-www-form-urlencoded')) {
-                        resolve(parseQuery(body));
+                    // Rejeita promise se o JSON for inválido
+                    try {
+                        resolve(JSON.parse(body));
                     }
-                    else {
-                        resolve(body);
+                    catch (e) {
+                        reject(new Error('Invalid JSON body'));
                     }
                 }
-                catch (error) {
-                    resolve(body); // Fallback para string se parsing falhar
+                else if (contentType.includes('application/x-www-form-urlencoded')) {
+                    // Usa API moderna URLSearchParams (segura contra prototype pollution)
+                    resolve(Object.fromEntries(new url_1.URLSearchParams(body)));
                 }
-            });
-            req.on('error', (error) => {
-                clearTimeout(timeout);
+                else {
+                    resolve(body); // Fallback para texto plano
+                }
+            }
+            catch (error) {
+                // Pega qualquer outro erro síncrono
                 reject(error);
-            });
+            }
         });
-    };
-    // Cria o servidor HTTP nativo com configurações de segurança
-    const server = http.createServer(async (req, res) => {
+        req.on('error', (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
+};
+/**
+ * Inicializa servidor nativo do HightJS usando HTTP ou HTTPS
+ */
+async function initNativeServer(hwebApp, options, port, hostname) {
+    const time = Date.now();
+    await hwebApp.prepare();
+    const handler = hwebApp.getRequestHandler();
+    const msg = console_1.default.dynamicLine(`    ${console_1.Colors.BgYellow} ready ${console_1.Colors.Reset}  ${console_1.Colors.Bright}Iniciando HightJS na porta ${options.port}${console_1.Colors.Reset}`);
+    // --- LÓGICA DO LISTENER (REUTILIZÁVEL) ---
+    // Extraímos a lógica principal para uma variável
+    // para que possa ser usada tanto pelo servidor HTTP quanto HTTPS.
+    const requestListener = async (req, res) => {
         // Configurações de segurança básicas
         res.setHeader('X-Content-Type-Options', 'nosniff');
         res.setHeader('X-Frame-Options', 'DENY');
         res.setHeader('X-XSS-Protection', '1; mode=block');
         res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
-        // Timeout para requisições
+        // IMPORTANTE: Adiciona HSTS (Strict-Transport-Security) se estiver em modo SSL
+        // Isso força o navegador a usar HTTPS no futuro.
+        if (options.ssl) {
+            res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
+        }
+        // Timeout por requisição
         req.setTimeout(30000, () => {
             res.statusCode = 408; // Request Timeout
             res.end('Request timeout');
         });
         try {
-            // Validação básica de URL para prevenir ataques
+            // Validação básica de URL
             const url = req.url || '/';
             if (url.length > 2048) {
                 res.statusCode = 414; // URI Too Long
@@ -272,16 +211,22 @@ async function initNativeServer(hwebApp, options, port, hostname) {
                 return;
             }
             // Parse do body com proteções
-            req.body = await parseBody(req);
-            // Adiciona host se não existir
+            req.body = await parseBody(req); // Assumindo que parseBody existe
+            // Adiciona host se não existir (necessário para `new URL`)
             req.headers.host = req.headers.host || `localhost:${port}`;
             // Chama o handler do HightJS
             await handler(req, res);
         }
         catch (error) {
-            console_1.default.error('Erro no servidor nativo:', error);
+            // Log do erro no servidor
+            if (error instanceof Error) {
+                console_1.default.error(`Erro no servidor nativo: ${error.message}`);
+            }
+            else {
+                console_1.default.error('Erro desconhecido no servidor nativo:', error);
+            }
+            // Tratamento de erro (idêntico ao seu original)
             if (!res.headersSent) {
-                res.statusCode = 500;
                 res.setHeader('Content-Type', 'text/plain');
                 if (error instanceof Error) {
                     if (error.message.includes('too large')) {
@@ -292,27 +237,168 @@ async function initNativeServer(hwebApp, options, port, hostname) {
                         res.statusCode = 408; // Request Timeout
                         res.end('Request timeout');
                     }
+                    else if (error.message.includes('Invalid JSON')) {
+                        res.statusCode = 400; // Bad Request
+                        res.end('Invalid JSON body');
+                    }
                     else {
+                        res.statusCode = 500;
                         res.end('Internal server error');
                     }
                 }
                 else {
+                    res.statusCode = 500;
                     res.end('Internal server error');
                 }
             }
         }
-    });
-    // Configurações de segurança do servidor
+    };
+    // --- FIM DO LISTENER ---
+    let server; // O tipo do servidor pode variar
+    const isSSL = options.ssl && options.ssl.key && options.ssl.cert;
+    if (isSSL && options.ssl) {
+        const sslOptions = {
+            key: fs_1.default.readFileSync(options.ssl.key),
+            cert: fs_1.default.readFileSync(options.ssl.cert),
+            ca: options.ssl.ca ? fs_1.default.readFileSync(options.ssl.ca) : undefined
+        };
+        // 1. Cria o servidor HTTPS principal
+        server = https_1.default.createServer(sslOptions, requestListener); // (any para contornar HWebIncomingMessage)
+        // 2. Cria o servidor de REDIRECIONAMENTO (HTTP -> HTTPS)
+        const httpRedirectPort = options.ssl.redirectPort;
+        http_1.default.createServer((req, res) => {
+            const host = req.headers['host'] || hostname;
+            // Remove a porta do host (ex: meusite.com:80)
+            const hostWithoutPort = host.split(':')[0];
+            // Monta a URL de redirecionamento
+            let redirectUrl = `https://${hostWithoutPort}`;
+            // Adiciona a porta HTTPS apenas se não for a padrão (443)
+            if (port !== 443) {
+                redirectUrl += `:${port}`;
+            }
+            redirectUrl += req.url || '/';
+            res.writeHead(301, { 'Location': redirectUrl });
+            res.end();
+        }).listen(httpRedirectPort, hostname, () => { });
+    }
+    else {
+        // --- MODO HTTP (Original) ---
+        // Cria o servidor HTTP nativo
+        server = http_1.default.createServer(requestListener); // (any para contornar HWebIncomingMessage)
+    }
+    // Configurações de segurança do servidor (Comum a ambos)
     server.setTimeout(35000); // Timeout geral do servidor
     server.maxHeadersCount = 100; // Limita número de headers
     server.headersTimeout = 60000; // Timeout para headers
     server.requestTimeout = 30000; // Timeout para requisições
     server.listen(port, hostname, () => {
         sendBox({ ...options, port });
-        msg.end(`  ${console_1.Colors.FgGreen}⚡  ${console_1.Colors.Reset}${console_1.Colors.Bright}Servidor HightJS NATIVO ativo!${console_1.Colors.Reset}`);
+        msg.end(`  ${console_1.Colors.BgGreen} ready ${console_1.Colors.Reset}    ${console_1.Colors.Bright}Pronto na porta ${console_1.Colors.BgGreen} ${options.port} ${console_1.Colors.Reset}${console_1.Colors.Bright} em ${Date.now() - time}ms${console_1.Colors.Reset}\n`);
     });
-    // Configura WebSocket para hot reload
+    // Configura WebSocket para hot reload (Comum a ambos)
     hwebApp.setupWebSocket(server);
     hwebApp.executeInstrumentation();
     return server;
 }
+// --- Função Principal ---
+function app(options = {}) {
+    const framework = options.framework || 'native';
+    index_1.FrameworkAdapterFactory.setFramework(framework);
+    // Tipando a app principal do hweb
+    const hwebApp = (0, index_1.default)(options);
+    return {
+        ...hwebApp,
+        /**
+         * Integra com uma aplicação de qualquer framework (Express, Fastify, etc)
+         * O 'serverApp: any' é mantido para flexibilidade, já que pode ser de tipos diferentes.
+         */
+        integrate: async (serverApp) => {
+            await hwebApp.prepare();
+            const handler = hwebApp.getRequestHandler();
+            // O framework é setado nas opções do hweb, que deve
+            // retornar o handler correto em getRequestHandler()
+            // A lógica de integração original parece correta.
+            if (framework === 'express') {
+                const express = require('express');
+                try {
+                    const cookieParser = require('cookie-parser');
+                    serverApp.use(cookieParser());
+                }
+                catch (e) {
+                    console_1.default.error("Não foi possivel achar cookie-parser");
+                }
+                serverApp.use(express.json());
+                serverApp.use(express.urlencoded({ extended: true }));
+                serverApp.use(handler);
+                hwebApp.setupWebSocket(serverApp);
+            }
+            else if (framework === 'fastify') {
+                try {
+                    await serverApp.register(require('@fastify/cookie'));
+                }
+                catch (e) {
+                    console_1.default.error("Não foi possivel achar @fastify/cookie");
+                }
+                try {
+                    await serverApp.register(require('@fastify/formbody'));
+                }
+                catch (e) {
+                    console_1.default.error("Não foi possivel achar @fastify/formbody");
+                }
+                await serverApp.register(async (fastify) => {
+                    fastify.all('*', handler);
+                });
+                hwebApp.setupWebSocket(serverApp);
+            }
+            else {
+                // Generic integration (assume Express-like)
+                serverApp.use(handler);
+                hwebApp.setupWebSocket(serverApp);
+            }
+            hwebApp.executeInstrumentation();
+            return serverApp;
+        },
+        /**
+         * Inicia um servidor HightJS fechado (o usuário não tem acesso ao framework)
+         */
+        init: async () => {
+            const currentVersion = require('../package.json').version;
+            async function verifyVersion() {
+                // node fetch
+                try {
+                    const response = await fetch('https://registry.npmjs.org/hightjs/latest');
+                    const data = await response.json();
+                    return data.version;
+                }
+                catch (error) {
+                    console_1.default.error('Não foi possível verificar a versão mais recente do HightJS:', error);
+                    return currentVersion; // Retorna a versão atual em caso de erro
+                }
+            }
+            const latestVersion = await verifyVersion();
+            const isUpToDate = latestVersion === currentVersion;
+            let message;
+            if (!isUpToDate) {
+                message = `${console_1.Colors.FgGreen}   Há uma nova versão disponível (v${latestVersion})${console_1.Colors.FgMagenta}`;
+            }
+            else {
+                message = `${console_1.Colors.FgGreen}   Você está na versão mais recente${console_1.Colors.FgMagenta}`;
+            }
+            console.log(`${console_1.Colors.FgMagenta}
+            __       ___ ${console_1.Colors.FgGreen}      __  ${console_1.Colors.FgMagenta}
+    |__| | / _\` |__|  |  ${console_1.Colors.FgGreen}   | /__\` ${console_1.Colors.FgMagenta}   ${console_1.Colors.FgMagenta}HightJS ${console_1.Colors.FgGray}(v${require('../package.json').version}) - itsmuzin${console_1.Colors.FgMagenta}
+    |  | | \\__> |  |  |  ${console_1.Colors.FgGreen}\\__/ .__/ ${message}
+                               
+                               
+              ${console_1.Colors.Reset}`);
+            const actualPort = options.port || 3000;
+            const actualHostname = options.hostname || "0.0.0.0";
+            if (framework !== 'native') {
+                console_1.default.warn(`O framework "${framework}" foi selecionado, mas o método init() só funciona com o framework "native". Iniciando servidor nativo...`);
+            }
+            return await initNativeServer(hwebApp, options, actualPort, actualHostname);
+        }
+    };
+}
+// Exporta a função 'app' como nomeada e também como padrão
+exports.default = app;

package/dist/hotReload.js

@@ -34,6 +34,22 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HotReloadManager = void 0;
+/*
+ * This file is part of the HightJS Project.
+ * Copyright (c) 2025 itsmuzin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 const ws_1 = require("ws");
 const chokidar = __importStar(require("chokidar"));
 const path = __importStar(require("path"));
@@ -108,10 +124,10 @@ class HotReloadManager {
                 this.cleanupClient(ws);
             });
             ws.on('error', (error) => {
-                console_1.default.logWithout(console_1.Levels.ERROR, `WebSocket error: ${error.message}`);
+                console_1.default.logWithout(console_1.Levels.ERROR, console_1.Colors.BgRed, `WebSocket error: ${error.message}`);
                 this.cleanupClient(ws);
             });
-            console_1.default.logWithout(console_1.Levels.INFO, '🔌 Hot-reload cliente conectado');
+            console_1.default.logWithout(console_1.Levels.INFO, console_1.Colors.BgRed, '🔌 Hot-reload cliente conectado');
         });
     }
     cleanupClient(ws) {
@@ -170,7 +186,7 @@ class HotReloadManager {
         };
     }
     async handleAnySrcChange(filePath) {
-        console_1.default.logWithout(console_1.Levels.INFO, `🔄 Arquivo alterado: ${path.basename(filePath)}`);
+        console_1.default.logWithout(console_1.Levels.INFO, console_1.Colors.BgRed, `🔄 Arquivo alterado: ${path.basename(filePath)}`);
         // Detecta se é arquivo de frontend ou backend
         const isFrontendFile = filePath.includes(path.join('src', 'web', 'routes')) ||
             filePath.includes(path.join('src', 'web', 'components')) ||
@@ -194,19 +210,19 @@ class HotReloadManager {
         }
         // Se for arquivo de frontend, notifica o cliente para recarregar a página
         if (isFrontendFile) {
-            console_1.default.logWithout(console_1.Levels.INFO, `📄 Recarregando frontend...`);
+            console_1.default.logWithout(console_1.Levels.INFO, console_1.Colors.BgRed, `📄 Recarregando frontend...`);
             this.frontendChangeCallback?.();
             this.notifyClients('frontend-reload', { file: filePath, event: 'change' });
         }
         // Se for arquivo de backend, recarrega o módulo e notifica
         if (isBackendFile) {
-            console_1.default.logWithout(console_1.Levels.INFO, `⚙️ Recarregando backend...`);
+            console_1.default.logWithout(console_1.Levels.INFO, console_1.Colors.BgRed, `⚙️ Recarregando backend...`);
             this.backendApiChangeCallback?.();
             this.notifyClients('backend-api-reload', { file: filePath, event: 'change' });
         }
         // Fallback: se não for nem frontend nem backend detectado, recarrega tudo
         if (!isFrontendFile && !isBackendFile) {
-            console_1.default.logWithout(console_1.Levels.INFO, `🔄 Recarregando aplicação...`);
+            console_1.default.logWithout(console_1.Levels.INFO, console_1.Colors.BgRed, `🔄 Recarregando aplicação...`);
             this.frontendChangeCallback?.();
             this.backendApiChangeCallback?.();
             this.notifyClients('src-reload', { file: filePath, event: 'change' });
@@ -234,7 +250,7 @@ class HotReloadManager {
                     ws.send(message);
                 }
                 catch (error) {
-                    console_1.default.logWithout(console_1.Levels.ERROR, `Erro ao enviar mensagem WebSocket: ${error}`);
+                    console_1.default.logWithout(console_1.Levels.ERROR, console_1.Colors.BgRed, `Erro ao enviar mensagem WebSocket: ${error}`);
                     deadClients.push(ws);
                 }
             }