nyte 1.0.0

package/dist/helpers.js

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+"use strict";
+/*
+ * This file is part of the Nyte.js Project.
+ * Copyright (c) 2026 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);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = app;
+// 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'
+const path_1 = __importDefault(require("path"));
+// 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
+// Registra loaders customizados para importar arquivos não-JS
+const { registerLoaders } = require('./loaders');
+registerLoaders();
+// --- Helpers ---
+/**
+ * Encontra o IP externo local (rede)
+ */
+function getLocalExternalIp() {
+    const interfaces = os_1.default.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        const ifaceList = interfaces[name];
+        if (ifaceList) {
+            for (const iface of ifaceList) {
+                if (iface.family === 'IPv4' && !iface.internal) {
+                    return iface.address;
+                }
+            }
+        }
+    }
+    return 'localhost'; // Fallback
+}
+const sendBox = (options) => {
+    const isDev = options.dev;
+    const isSSL = options.ssl && options.ssl.key && options.ssl.cert;
+    const protocol = isSSL ? 'https' : 'http';
+    const localIp = getLocalExternalIp();
+    // Estilos Clean
+    const labelStyle = console_1.Colors.FgGray;
+    const urlStyle = console_1.Colors.Bright + console_1.Colors.FgCyan; // Ciano para links é o padrão mais legível
+    const now = new Date();
+    const time = now.toLocaleTimeString('pt-BR', { hour12: false });
+    const timer = ` ${console_1.Colors.FgGray}${time}${console_1.Colors.Reset}  `;
+    // Pequeno espaçamento visual antes dos logs de acesso
+    console.log('');
+    console.log(timer + labelStyle + ' Access on:');
+    console.log(' ');
+    // 1. Local (Alinhamento: Local tem 6 letras + 4 espaços = 10)
+    console.info(timer + `${labelStyle}  ┃  Local:${console_1.Colors.Reset}    ${urlStyle}${protocol}://localhost:${options.port}${console_1.Colors.Reset}`);
+    // 2. Network (Alinhamento: Network tem 8 letras + 2 espaços = 10)
+    if (localIp) {
+        console.info(timer + `${labelStyle}  ┃  Network:${console_1.Colors.Reset}  ${urlStyle}${protocol}://${localIp}:${options.port}${console_1.Colors.Reset}`);
+    }
+    // 3. Infos Extras (Redirect HTTP -> HTTPS)
+    if (isSSL && options.ssl?.redirectPort) {
+        console.info(timer + `${labelStyle}  ┃  Redirect:${console_1.Colors.Reset} ${labelStyle}port ${options.ssl.redirectPort} ➜ https${console_1.Colors.Reset}`);
+    }
+    // 4. Info de Ambiente
+    if (isDev) {
+        console.info(timer + `${labelStyle}  ┃  Mode:${console_1.Colors.Reset}     ${console_1.Colors.FgAlmostWhite}development${console_1.Colors.Reset}`);
+    }
+    // Espaçamento final
+    console.log('\n');
+};
+/**
+ * Carrega o arquivo de configuração nytejs.config.ts ou nytejs.config.js do projeto
+ * @param projectDir Diretório raiz do projeto
+ * @param phase Fase de execução ('development' ou 'production')
+ * @returns Configuração mesclada com os valores padrão
+ */
+async function loadNyteConfig(projectDir, phase) {
+    const defaultConfig = {
+        maxHeadersCount: 100,
+        headersTimeout: 60000,
+        requestTimeout: 30000,
+        serverTimeout: 35000,
+        individualRequestTimeout: 30000,
+        maxUrlLength: 2048,
+        accessLogging: true,
+    };
+    try {
+        // Tenta primeiro .ts, depois .js
+        const possiblePaths = [
+            path_1.default.join(projectDir, 'nytejs.config.ts'),
+            path_1.default.join(projectDir, 'nytejs.config.js'),
+        ];
+        let configPath = null;
+        for (const p of possiblePaths) {
+            if (fs_1.default.existsSync(p)) {
+                configPath = p;
+                break;
+            }
+        }
+        if (!configPath) {
+            return defaultConfig;
+        }
+        // Remove do cache para permitir hot reload da configuração em dev
+        delete require.cache[require.resolve(configPath)];
+        const configModule = require(configPath);
+        const configExport = configModule.default || configModule;
+        let userConfig;
+        if (typeof configExport === 'function') {
+            // Suporta tanto função síncrona quanto assíncrona
+            userConfig = await Promise.resolve(configExport(phase, { defaultConfig }));
+        }
+        else {
+            userConfig = configExport;
+        }
+        // Mescla a configuração do usuário com a padrão
+        const mergedConfig = { ...defaultConfig, ...userConfig };
+        const configFileName = path_1.default.basename(configPath);
+        console_1.default.info(`Loaded ${configFileName}`);
+        return mergedConfig;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console_1.default.warn(`${console_1.Colors.FgYellow}[Config]${console_1.Colors.Reset} Error loading nytejs.config: ${error.message}`);
+            console_1.default.warn(`${console_1.Colors.FgYellow}[Config]${console_1.Colors.Reset} Using default configuration`);
+        }
+        return defaultConfig;
+    }
+}
+/**
+ * Aplica headers CORS na resposta baseado na configuração.
+ * @param req Requisição HTTP
+ * @param res Resposta HTTP
+ * @param corsConfig Configuração de CORS
+ * @returns true se a requisição foi finalizada (OPTIONS), false caso contrário
+ */
+function applyCors(req, res, corsConfig) {
+    if (!corsConfig || !corsConfig.enabled) {
+        return false;
+    }
+    const origin = req.headers.origin || req.headers.referer;
+    // Verifica se a origem é permitida
+    let allowOrigin = false;
+    if (corsConfig.origin === '*') {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        allowOrigin = true;
+    }
+    else if (typeof corsConfig.origin === 'string' && origin === corsConfig.origin) {
+        res.setHeader('Access-Control-Allow-Origin', corsConfig.origin);
+        allowOrigin = true;
+    }
+    else if (Array.isArray(corsConfig.origin) && origin && corsConfig.origin.includes(origin)) {
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        allowOrigin = true;
+    }
+    else if (typeof corsConfig.origin === 'function' && origin) {
+        try {
+            if (corsConfig.origin(origin)) {
+                res.setHeader('Access-Control-Allow-Origin', origin);
+                allowOrigin = true;
+            }
+        }
+        catch (error) {
+            console_1.default.warn(`${console_1.Colors.FgYellow}[CORS]${console_1.Colors.Reset} Error validating origin: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    // Se a origem não for permitida e não for wildcard, não aplica outros headers
+    if (!allowOrigin && corsConfig.origin !== '*') {
+        return false;
+    }
+    // Credenciais (não pode ser usado com origin: '*')
+    if (corsConfig.credentials && corsConfig.origin !== '*') {
+        res.setHeader('Access-Control-Allow-Credentials', 'true');
+    }
+    // Métodos permitidos
+    const methods = corsConfig.methods || ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'];
+    res.setHeader('Access-Control-Allow-Methods', methods.join(', '));
+    // Headers permitidos
+    const allowedHeaders = corsConfig.allowedHeaders || ['Content-Type', 'Authorization'];
+    res.setHeader('Access-Control-Allow-Headers', allowedHeaders.join(', '));
+    // Headers expostos
+    if (corsConfig.exposedHeaders && corsConfig.exposedHeaders.length > 0) {
+        res.setHeader('Access-Control-Expose-Headers', corsConfig.exposedHeaders.join(', '));
+    }
+    // Max age para cache de preflight
+    const maxAge = corsConfig.maxAge !== undefined ? corsConfig.maxAge : 86400;
+    res.setHeader('Access-Control-Max-Age', maxAge.toString());
+    // Responde requisições OPTIONS (preflight)
+    if (req.method === 'OPTIONS') {
+        res.statusCode = 204; // No Content
+        res.end();
+        return true;
+    }
+    return false;
+}
+/**
+ * Middleware para parsing do body com proteções de segurança (versão melhorada).
+*/
+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;
+            }
+            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;
+                    }
+                    // Rejeita promise se o JSON for inválido
+                    try {
+                        resolve(JSON.parse(body));
+                    }
+                    catch (e) {
+                        reject(new Error('Invalid JSON body'));
+                    }
+                }
+                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)));
+                }
+                else {
+                    resolve(body); // Fallback para texto plano
+                }
+            }
+            catch (error) {
+                // Pega qualquer outro erro síncrono
+                reject(error);
+            }
+        });
+        req.on('error', (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
+};
+/**
+ * Inicializa servidor nativo do Nyte.js usando HTTP ou HTTPS
+ */
+async function initNativeServer(hwebApp, options, port, hostname) {
+    const time = Date.now();
+    await hwebApp.prepare();
+    // Carrega a configuração do arquivo nytejs.config.js
+    const projectDir = options.dir || process.cwd();
+    const phase = options.dev ? 'development' : 'production';
+    const nyteConfig = await loadNyteConfig(projectDir, phase);
+    const handler = hwebApp.getRequestHandler();
+    const msg = console_1.default.dynamicLine(`${console_1.Colors.Bright}Starting Nyte.js on port ${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) => {
+        const requestStartTime = Date.now();
+        const method = req.method || 'GET';
+        const url = req.url || '/';
+        // Aplica CORS se configurado
+        const corsHandled = applyCors(req, res, nyteConfig.cors);
+        if (corsHandled) {
+            // Requisição OPTIONS foi respondida pelo CORS
+            if (nyteConfig.accessLogging) {
+                const duration = Date.now() - requestStartTime;
+                console_1.default.logCustomLevel('OPTIONS', true, console_1.Colors.BgMagenta, `${url} ${console_1.Colors.FgGreen}204${console_1.Colors.Reset} ${console_1.Colors.FgGray}${duration}ms${console_1.Colors.Reset} ${console_1.Colors.FgCyan}[CORS]${console_1.Colors.Reset}`);
+            }
+            return;
+        }
+        // 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');
+        // Aplica headers de segurança configurados
+        if (nyteConfig.security?.contentSecurityPolicy) {
+            res.setHeader('Content-Security-Policy', nyteConfig.security.contentSecurityPolicy);
+        }
+        if (nyteConfig.security?.permissionsPolicy) {
+            res.setHeader('Permissions-Policy', nyteConfig.security.permissionsPolicy);
+        }
+        const hstsValue = nyteConfig.security?.strictTransportSecurity || 'max-age=31536000; includeSubDomains';
+        res.setHeader('Strict-Transport-Security', hstsValue);
+        // Aplica headers personalizados
+        if (nyteConfig.customHeaders) {
+            for (const [headerName, headerValue] of Object.entries(nyteConfig.customHeaders)) {
+                res.setHeader(headerName, headerValue);
+            }
+        }
+        // Timeout por requisição (usa configuração personalizada)
+        req.setTimeout(nyteConfig.individualRequestTimeout || 30000, () => {
+            res.statusCode = 408; // Request Timeout
+            res.end('Request timeout');
+            // Log de timeout
+            if (nyteConfig.accessLogging) {
+                const duration = Date.now() - requestStartTime;
+                console_1.default.info(`${console_1.Colors.FgYellow}${method}${console_1.Colors.Reset} ${url} ${console_1.Colors.FgRed}408${console_1.Colors.Reset} ${console_1.Colors.FgGray}${duration}ms${console_1.Colors.Reset}`);
+            }
+        });
+        // Intercepta o método end() para logar quando a resposta for enviada
+        const originalEnd = res.end.bind(res);
+        let hasEnded = false;
+        res.end = function (...args) {
+            if (!hasEnded && nyteConfig.accessLogging) {
+                hasEnded = true;
+                const duration = Date.now() - requestStartTime;
+                const statusCode = res.statusCode || 200;
+                // Define cor baseada no status code
+                let statusColor = console_1.Colors.FgGreen; // 2xx
+                if (statusCode >= 500)
+                    statusColor = console_1.Colors.FgRed; // 5xx
+                else if (statusCode >= 400)
+                    statusColor = console_1.Colors.FgYellow; // 4xx
+                else if (statusCode >= 300)
+                    statusColor = console_1.Colors.FgCyan; // 3xx
+                // Formata o método com cor
+                let methodColor = console_1.Colors.FgCyan;
+                if (method === 'POST')
+                    methodColor = console_1.Colors.FgGreen;
+                else if (method === 'PUT')
+                    methodColor = console_1.Colors.FgYellow;
+                else if (method === 'DELETE')
+                    methodColor = console_1.Colors.FgRed;
+                else if (method === 'PATCH')
+                    methodColor = console_1.Colors.FgMagenta;
+                console_1.default.logCustomLevel(method, true, methodColor, `${url} ${statusColor}${statusCode}${console_1.Colors.Reset} ${console_1.Colors.FgGray}${duration}ms${console_1.Colors.Reset}`);
+            }
+            // @ts-ignore
+            return originalEnd.apply(this, args);
+        };
+        try {
+            // Validação básica de URL (usa configuração personalizada)
+            const maxUrlLength = nyteConfig.maxUrlLength || 2048;
+            if (url.length > maxUrlLength) {
+                res.statusCode = 414; // URI Too Long
+                res.end('URL too long');
+                return;
+            }
+            // Parse do body com proteções
+            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 Nyte.js
+            await handler(req, res);
+        }
+        catch (error) {
+            // Log do erro no servidor
+            if (error instanceof Error) {
+                console_1.default.error(`Native server error: ${error.message}`);
+            }
+            else {
+                console_1.default.error('Unknown native server error:', error);
+            }
+            // Tratamento de erro (idêntico ao seu original)
+            if (!res.headersSent) {
+                res.setHeader('Content-Type', 'text/plain');
+                if (error instanceof Error) {
+                    if (error.message.includes('too large')) {
+                        res.statusCode = 413; // Payload Too Large
+                        res.end('Request too large');
+                    }
+                    else if (error.message.includes('timeout')) {
+                        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');
+                }
+            }
+        }
+    };
+    // --- 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 (usa configuração personalizada)
+    server.setTimeout(nyteConfig.serverTimeout || 35000); // Timeout geral do servidor
+    server.maxHeadersCount = nyteConfig.maxHeadersCount || 100; // Limita número de headers
+    server.headersTimeout = nyteConfig.headersTimeout || 60000; // Timeout para headers
+    server.requestTimeout = nyteConfig.requestTimeout || 30000; // Timeout para requisições
+    server.listen(port, hostname, () => {
+        sendBox({ ...options, port });
+        msg.end(`${console_1.Colors.Bright}Ready on port ${console_1.Colors.BgGreen} ${options.port} ${console_1.Colors.Reset}${console_1.Colors.Bright} in ${Date.now() - time}ms${console_1.Colors.Reset}\n`);
+    });
+    // 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("Could not find 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("Could not find @fastify/cookie");
+                }
+                try {
+                    await serverApp.register(require('@fastify/formbody'));
+                }
+                catch (e) {
+                    console_1.default.error("Could not find @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 Nyte.js 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/nyte/latest');
+                    const data = await response.json();
+                    return data.version;
+                }
+                catch (error) {
+                    console_1.default.error('Could not check for the latest Nyte.js version:', 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.FgRed}   A new version is available (v${latestVersion})${console_1.Colors.FgMagenta}`;
+            }
+            else {
+                message = `${console_1.Colors.FgGreen}   You are on the latest version${console_1.Colors.FgMagenta}`;
+            }
+            // JS STICK LETTERS
+            console.log(`${console_1.Colors.Bright + console_1.Colors.FgCyan}
+${console_1.Colors.Bright + console_1.Colors.FgCyan}             ___  ___    ${console_1.Colors.FgWhite}        __  
+${console_1.Colors.Bright + console_1.Colors.FgCyan}    |\\ | \\ /  |  |__   ${console_1.Colors.FgWhite}       | /__\`    ${console_1.Colors.Bright + console_1.Colors.FgCyan}Nyte${console_1.Colors.FgWhite}.js ${console_1.Colors.FgGray}(v${require('../package.json').version}) - itsmuzin${console_1.Colors.FgMagenta}
+${console_1.Colors.Bright + console_1.Colors.FgCyan}    | \\|  |   |  |___  .${console_1.Colors.FgWhite}   \\__/ .__/ ${message}
+                                
+            `);
+            const actualPort = options.port || 3000;
+            const actualHostname = options.hostname || "0.0.0.0";
+            if (framework !== 'native') {
+                console_1.default.warn(`The "${framework}" framework was selected, but the init() method only works with the "native" framework. Starting native server...`);
+            }
+            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.d.ts

@@ -0,0 +1,32 @@
+import { IncomingMessage } from 'http';
+export declare class HotReloadManager {
+    private wss;
+    private watchers;
+    private projectDir;
+    private clients;
+    private backendApiChangeCallback;
+    private frontendChangeCallback;
+    private isShuttingDown;
+    private debounceTimers;
+    private customHotReloadListener;
+    private isBuilding;
+    private buildCompleteResolve;
+    constructor(projectDir: string);
+    start(): Promise<void>;
+    handleUpgrade(request: IncomingMessage, socket: any, head: Buffer): void;
+    private setupWebSocketServer;
+    private cleanupClient;
+    private setupWatchers;
+    private debounce;
+    private handleAnySrcChange;
+    private notifyClients;
+    private restartServer;
+    stop(): void;
+    getClientScript(): string;
+    private clearBackendCache;
+    onBackendApiChange(callback: () => void): void;
+    onFrontendChange(callback: () => void): void;
+    setHotReloadListener(listener: (file: string) => Promise<void> | void): void;
+    removeHotReloadListener(): void;
+    onBuildComplete(success: boolean): void;
+}