@purecore/one-server-4-all 0.1.0

package/dist/validator.js

@@ -0,0 +1,49 @@
+/**
+ * Um mini-validador type-safe inspirado no Zod.
+ * Garante que nossa configuração de entrada seja válida sem importar bibliotecas externas.
+ */
+export class Schema {
+    validator;
+    constructor(validator) {
+        this.validator = validator;
+    }
+    parse(value) {
+        return this.validator(value);
+    }
+}
+export const z = {
+    string: () => new Schema((val) => {
+        if (typeof val !== 'string')
+            throw new Error(`Expected string, received ${typeof val}`);
+        return val;
+    }),
+    number: () => new Schema((val) => {
+        const num = Number(val);
+        if (isNaN(num))
+            throw new Error(`Expected number, received ${val}`);
+        return num;
+    }),
+    object: (shape) => new Schema((val) => {
+        if (typeof val !== 'object' || val === null)
+            throw new Error("Expected object");
+        const result = {};
+        const obj = val;
+        for (const key in shape) {
+            try {
+                result[key] = shape[key].parse(obj[key]);
+            }
+            catch (e) {
+                throw new Error(`In field '${key}': ${e.message}`);
+            }
+        }
+        return result;
+    })
+};
+// Configuração Schema para o nosso servidor
+export const configSchema = z.object({
+    port: z.number(),
+    root: z.string(),
+    open: z.string(), // boolean as string 'true'/'false' simplificado para CLI
+    spa: z.string(), // boolean as string 'true'/'false' para suporte SPA
+    https: z.string() // boolean as string 'true'/'false' para modo HTTPS
+});

package/dist/watcher.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+export class Watcher extends EventEmitter {
+    root;
+    timeout = null;
+    watcher = null;
+    constructor(root) {
+        super();
+        this.root = path.resolve(root);
+    }
+    start() {
+        if (!fs.existsSync(this.root)) {
+            console.error(`❌ Diretório não encontrado: ${this.root}`);
+            return;
+        }
+        try {
+            // Recursive watch é suportado na maioria dos OS modernos Node v20+
+            // No Linux pode ter limitações dependendo do FS, mas para dev local funciona bem.
+            this.watcher = fs.watch(this.root, { recursive: true }, (eventType, filename) => {
+                if (filename && !this.isIgnored(filename.toString())) {
+                    this.debounceChange(filename.toString());
+                }
+            });
+            console.log(`👀 Observando mudanças em: ${this.root}`);
+        }
+        catch (err) {
+            console.error("Erro ao iniciar watcher:", err);
+            // Fallback para não-recursivo se falhar (ex: Linux kernels antigos)
+            console.warn("⚠️ Fallback para watcher não recursivo.");
+            this.watcher = fs.watch(this.root, (event, filename) => {
+                if (filename)
+                    this.debounceChange(filename.toString());
+            });
+        }
+    }
+    isIgnored(filename) {
+        // Ignorar node_modules e arquivos ocultos (.git, etc)
+        return filename.includes('node_modules') ||
+            filename.includes('.git') ||
+            filename.endsWith('.tmp');
+    }
+    debounceChange(filename) {
+        // Evita múltiplos disparos (ex: salvar arquivo dispara 2 eventos 'change' e 'rename')
+        if (this.timeout)
+            clearTimeout(this.timeout);
+        this.timeout = setTimeout(() => {
+            console.log(`🔄 Arquivo alterado: ${filename}`);
+            this.emit('change', filename);
+        }, 100); // 100ms debounce
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+}

package/hot-server.deps.graflow

@@ -0,0 +1 @@
+(hot-server)->(0.1.0)

package/install-ignite.ps1

@@ -0,0 +1,26 @@
+$ignitePath = "$env:USERPROFILE\.purecore\ignite"
+$binPath = "$env:USERPROFILE\.purecore\bin"
+
+Write-Host "Installing PureCore Ignite..."
+
+New-Item -ItemType Directory -Force -Path $ignitePath | Out-Null
+New-Item -ItemType Directory -Force -Path $binPath | Out-Null
+
+Copy-Item .\ignite.exe "$ignitePath\ignite.exe" -Force
+
+$target = "$binPath\ignite.exe"
+$source = "$ignitePath\ignite.exe"
+
+cmd /c mklink $target $source | Out-Null
+
+$envPath = [Environment]::GetEnvironmentVariable("Path", "User")
+if ($envPath -notlike "*$binPath*") {
+  [Environment]::SetEnvironmentVariable(
+    "Path",
+    "$envPath;$binPath",
+    "User"
+  )
+}
+
+Write-Host "Ignite installed successfully."
+Write-Host "Restart your terminal and run: ignite"

package/install-ignite.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+set -e
+
+IGNITE_PATH="$HOME/.purecore/ignite"
+BIN_PATH="$HOME/.local/bin"
+
+mkdir -p "$IGNITE_PATH"
+mkdir -p "$BIN_PATH"
+
+echo "Installing PureCore Ignite..."
+
+# exemplo: copia binário ou script JS empacotado
+cp ./ignite "$IGNITE_PATH/ignite"
+chmod +x "$IGNITE_PATH/ignite"
+
+ln -sf "$IGNITE_PATH/ignite" "$BIN_PATH/ignite"
+
+if [[ ":$PATH:" != *":$BIN_PATH:"* ]]; then
+  echo "export PATH=\"$BIN_PATH:\$PATH\"" >> "$HOME/.bashrc"
+  echo "export PATH=\"$BIN_PATH:\$PATH\"" >> "$HOME/.zshrc"
+fi
+
+echo "Ignite installed successfully."
+echo "Restart your terminal and run: ignite"

package/jest.config.cjs

@@ -0,0 +1,7 @@
+module.exports = {
+  testEnvironment: 'node',
+  roots: ['<rootDir>/dist'],
+  testMatch: ['**/?(*.)+(spec|test).js'],
+  transform: {}, // sem ts-jest
+  moduleFileExtensions: ['js', 'json']
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@purecore/one-server-4-all",
+  "version": "0.1.0",
+  "description": "Zero dependency modern hot-reload server replacement",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "one-server": "./dist/index.js",
+    "vai-server": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "bun run src/index.ts",
+    "dev:https": "bun run src/index.ts --https=true",
+    "test": "jest",
+    "certs:generate": "bun run src/cert-generator.ts generate",
+    "certs:clean": "bun run src/cert-generator.ts clean",
+    "certs:info": "bun run src/cert-generator.ts info"
+  },
+  "keywords": [
+    "http-server",
+    "hot-reload",
+    "hot-server",
+    "live-server",
+    "zero-dependency"
+  ],
+  "author": "Suissa",
+  "license": "CEL",
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {}
+}

package/reports/21-12-2025_04-20.md

@@ -0,0 +1,154 @@
+# Relatório de Implementação: Purecore Hot Server - Funcionalidades Avançadas
+
+## 📋 Resumo das Implementações
+
+Foram implementadas com sucesso as 4 funcionalidades solicitadas do documento `COMPARACAO_LIVE_SERVER.md`, mantendo a filosofia **zero dependencies** do projeto.
+
+## ✅ Implementações Realizadas
+
+### 1. Injeção de CSS (CSS Hot Loading)
+
+**O que foi implementado:**
+- Script injetado no HTML agora diferencia mudanças em arquivos CSS de outros tipos
+- Quando um arquivo `.css` é modificado, em vez de recarregar toda a página, o sistema:
+  - Identifica os links `<link rel="stylesheet">` que referenciam o arquivo CSS alterado
+  - Adiciona um timestamp de cache busting (`?v=timestamp`) para forçar o reload do CSS
+  - Mantém o resto da página intacto
+
+**Arquivos modificados:**
+- `src/server.ts`: Script injetado e método `notifyClients()` atualizado
+- `src/watcher.ts`: Compatibilidade mantida
+
+**Técnicas utilizadas:**
+- JSON parsing no client-side para distinguir tipos de mudança
+- DOM manipulation para atualizar apenas CSS links
+- Fallback para compatibilidade com mensagens antigas
+
+### 2. Suporte a SPA (Single Page Applications)
+
+**O que foi implementado:**
+- Nova flag `--spa` (padrão: `false`)
+- Quando habilitado (`--spa=true`):
+  - Rotas não encontradas (404) redirecionam automaticamente para `index.html`
+  - Permite que frameworks como React/Vue assumam o controle do roteamento
+- Configuração integrada ao sistema de validação
+
+**Arquivos modificados:**
+- `src/index.ts`: Parsing da flag `--spa`
+- `src/validator.ts`: Schema atualizado para incluir configuração SPA
+- `src/server.ts`: Lógica de fallback para SPA implementada
+
+**Técnicas utilizadas:**
+- Validação type-safe com mini-Zod
+- Parsing de argumentos CLI robusto
+- Lógica condicional no handler de arquivos
+
+### 3. Mime-Types Robustos
+
+**O que foi implementado:**
+- Expansão significativa da lista `MIME_TYPES`
+- Suporte completo para:
+  - **Vídeos**: `.mp4`, `.webm`, `.ogg`, `.avi`, `.mov`, `.wmv`, `.flv`
+  - **Áudios**: `.mp3`, `.wav`, `.ogg`, `.aac`, `.m4a`, `.opus`
+  - **Fontes**: `.woff`, `.woff2`, `.ttf`, `.otf`, `.eot`
+  - **Imagens extras**: `.webp`, `.bmp`, `.tiff`, `.tif`
+  - **Documentos**: `.pdf`, `.csv`, `.yaml`, `.toml`
+  - **Arquivos comprimidos**: `.zip`, `.gzip`, `.tar`
+  - **Web**: `.webmanifest`
+
+**Arquivos modificados:**
+- `src/server.ts`: Lista `MIME_TYPES` expandida de ~10 para ~35 tipos
+
+**Técnicas utilizadas:**
+- Organização por categoria para manutenção
+- Cobertura abrangente de tipos modernos da web
+
+### 4. CORS (Cross-Origin Resource Sharing)
+
+**O que foi implementado:**
+- Headers CORS adicionados a todas as respostas de arquivos estáticos:
+  - `Access-Control-Allow-Origin: *`
+  - `Access-Control-Allow-Methods: GET, HEAD, OPTIONS`
+  - `Access-Control-Allow-Headers: Content-Type`
+- Aplicado tanto para arquivos HTML injetados quanto para arquivos binários/stream
+
+**Arquivos modificados:**
+- `src/server.ts`: Headers CORS adicionados em ambos os caminhos de resposta
+
+**Técnicas utilizadas:**
+- Headers aplicados consistentemente em todas as respostas
+- Suporte a métodos HTTP comuns
+- Configuração permissiva para desenvolvimento
+
+## 🔧 Arquitetura Mantida
+
+- **Zero Dependencies**: Todas as implementações usam apenas APIs nativas do Node.js
+- **TypeScript Estrito**: Código mantido com tipagem forte
+- **Performance**: Implementações otimizadas e eficientes
+- **Compatibilidade**: Fallback para funcionalidades antigas
+
+## 🧪 Como Testar
+
+### CSS Injection:
+```bash
+# Inicie o servidor
+npx ts-node src/index.ts
+
+# Modifique qualquer arquivo .css - deve atualizar sem reload da página
+```
+
+### SPA Support:
+```bash
+# Com suporte SPA
+npx ts-node src/index.ts --spa=true
+
+# Acesse qualquer rota inexistente - deve carregar index.html
+# Ex: http://localhost:9999/qualquer-rota-inexistente
+```
+
+### MIME Types:
+```bash
+# Sirva arquivos de diferentes tipos
+# Vídeos, fontes, manifestos agora são servidos com MIME types corretos
+```
+
+### CORS:
+```bash
+# Arquivos podem ser acessados de outros domínios/origins
+# Útil para desenvolvimento com múltiplos servidores locais
+```
+
+## 📈 Benefícios Alcançados
+
+1. **Performance Melhorada**: CSS injection evita reloads desnecessários
+2. **Compatibilidade SPA**: Suporte nativo a frameworks modernos
+3. **Robustez**: MIME types abrangentes para todos os tipos de arquivo
+4. **Flexibilidade**: CORS permite integrações cross-origin
+5. **Manutenibilidade**: Código organizado e bem documentado
+
+## 🎯 Resultado Final
+
+O Purecore Hot Server agora oferece funcionalidades comparáveis ao `live-server` mantendo sua vantagem principal: **zero dependencies**. As implementações são:
+
+- ✅ **Leves**: Sem adicionar dependências externas
+- ✅ **Eficientes**: Usam APIs nativas do Node.js
+- ✅ **Type-Safe**: Mantêm tipagem TypeScript rigorosa
+- ✅ **Compatíveis**: Funcionam com projetos existentes
+
+## 🔗 Fontes de Informação Utilizadas
+
+- [MDN Web Docs - MIME Types](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types)
+- [MDN Web Docs - CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)
+- [Node.js Documentation - HTTP Module](https://nodejs.org/api/http.html)
+- [TypeScript Handbook](https://www.typescriptlang.org/docs/)
+- [Server-Sent Events Specification](https://html.spec.whatwg.org/multipage/server-sent-events.html)
+
+## 📝 Próximos Passos
+
+O servidor agora está pronto para uso avançado com:
+- Hot reload inteligente (CSS injection + full reload)
+- Suporte SPA completo
+- MIME types robustos
+- CORS habilitado
+
+Para deploy em produção, considere adicionar configurações de segurança apropriadas.

package/reports/21-12-2025_04-21.md

@@ -0,0 +1,184 @@
+# Relatório de Implementação: HTTPS + Certificados Auto-Assinados + Logs Avançados
+
+## 🎯 Resumo das Implementações
+
+Foram implementadas com sucesso as funcionalidades de HTTPS, geração automática de certificados auto-assinados, e sistema avançado de logs com indicadores visuais e detalhamento de arquivos servidos.
+
+## ✅ Implementações Realizadas
+
+### 1. 🔒 Suporte Completo a HTTPS
+
+**O que foi implementado:**
+- Modo HTTPS opcional ativado pela flag `--https=true`
+- Geração automática de certificados SSL auto-assinados
+- Servidor HTTP/HTTPS dinâmico baseado na configuração
+- Suporte completo a protocolos HTTP e HTTPS
+
+**Arquivos modificados:**
+- `src/server.ts`: Classe HotServer modificada para suportar HTTPS
+- `src/index.ts`: Parsing da flag `--https`
+- `src/validator.ts`: Validação da configuração HTTPS
+
+**Técnicas utilizadas:**
+- Módulo `https` do Node.js para servidor SSL
+- Detecção automática de certificados existentes
+- Fallback gracioso para modo HTTP quando necessário
+- Protocol-aware browser opening
+
+### 2. 🛠️ Sistema de Geração de Certificados
+
+**O que foi implementado:**
+- Classe `CertGenerator` completa para gerenciamento de certificados
+- Geração automática de pares chave privada/certificado
+- Comandos CLI para geração, limpeza e informações
+- Certificados salvos em `.hot-server-certs/` padrão
+
+**Arquivos criados:**
+- `src/cert-generator.ts`: Sistema completo de geração de certificados
+
+**Técnicas utilizadas:**
+- Crypto API nativa do Node.js para geração RSA
+- File system operations para persistência
+- Command-line interface com subcomandos
+- Validação de existência de certificados
+
+### 3. 🔓🔒 Indicadores Visuais no Terminal
+
+**O que foi implementado:**
+- Emojis de cadeado no log de inicialização:
+  - 🔓 para modo HTTP (cadeado aberto)
+  - 🔒 para modo HTTPS (cadeado fechado)
+- URLs com protocolo correto (http/https)
+- Visual feedback imediato do modo de segurança
+
+**Arquivos modificados:**
+- `src/server.ts`: Logs de inicialização com indicadores visuais
+
+**Técnicas utilizadas:**
+- Template literals com emojis Unicode
+- Detecção dinâmica de protocolo
+- Console output formatting
+
+### 4. 📊 Sistema Avançado de Logs
+
+**O que foi implementado:**
+- Logs detalhados para cada arquivo servido
+- Informações de tamanho e tipo MIME
+- Parsing automático de recursos HTML
+- Detecção de CSS, JavaScript e imagens no HTML
+- Logs especiais para injeção de hot-reload
+
+**Arquivos modificados:**
+- `src/server.ts`: Sistema completo de logging
+
+**Técnicas utilizadas:**
+- Regex parsing para recursos HTML
+- File system stats para informações de tamanho
+- Formatação human-readable de bytes
+- Emoji categorization por tipo de recurso
+
+## 🔧 Funcionalidades Técnicas
+
+### Scripts NPM Adicionados
+```json
+{
+  "dev:https": "ts-node src/index.ts --https=true",
+  "certs:generate": "ts-node src/cert-generator.ts generate",
+  "certs:clean": "ts-node src/cert-generator.ts clean",
+  "certs:info": "ts-node src/cert-generator.ts info"
+}
+```
+
+### Estrutura de Certificados
+```
+.hot-server-certs/
+├── localhost.key    # Chave privada RSA
+└── localhost.crt    # Certificado auto-assinado
+```
+
+### Exemplo de Logs de Saída
+```
+🔐 Gerando certificados auto-assinados...
+✅ Certificados gerados com sucesso!
+
+🚀 Hot-Server rodando!
+-----------------------------------
+📂 Root:    /path/to/project
+🔒 Local:   https://localhost:9999
+-----------------------------------
+
+📄 Servindo: index.html (2.1 KB) [text/html]
+🔍 Recursos encontrados em index.html:
+  🎨 styles.css
+  📜 app.js
+  🖼️ logo.png
+🌐 HTML injetado com hot-reload: index.html
+```
+
+## 🧪 Como Testar
+
+### Modo HTTPS
+```bash
+# Ativar HTTPS
+npm run dev:https
+
+# Ou manualmente
+ts-node src/index.ts --https=true
+```
+
+### Gerenciamento de Certificados
+```bash
+# Gerar certificados
+npm run certs:generate
+
+# Ver informações
+npm run certs:info
+
+# Limpar certificados
+npm run certs:clean
+```
+
+### Logs Detalhados
+1. Inicie o servidor
+2. Abra uma página HTML no navegador
+3. Observe no terminal:
+   - 📄 Arquivos servidos com metadados
+   - 🔍 Recursos detectados automaticamente
+   - 🌐 Confirmação de injeção
+
+## 📈 Benefícios Alcançados
+
+### Segurança
+- ✅ Desenvolvimento local com HTTPS
+- ✅ Certificados auto-gerados automaticamente
+- ✅ Feedback visual de segurança
+
+### Desenvolvimento
+- ✅ Logs detalhados para debugging
+- ✅ Visibilidade de recursos HTML
+- ✅ Protocol-aware operations
+
+### Experiência do Desenvolvedor
+- ✅ Indicadores visuais claros
+- ✅ Automação de tarefas repetitivas
+- ✅ CLI intuitiva e completa
+
+## 🎯 Resultado Final
+
+O Purecore Hot Server agora oferece:
+
+- **🔒 HTTPS nativo** com certificados auto-assinados
+- **🛠️ Gerenciamento automático** de certificados SSL
+- **🔓🔒 Indicadores visuais** de segurança no terminal
+- **📊 Logs avançados** com parsing de recursos HTML
+- **📁 Informações detalhadas** de arquivos servidos
+
+**Mantendo a filosofia zero dependencies e arquitetura moderna!** 🚀
+
+## 🔗 Fontes de Informação Utilizadas
+
+- [Node.js HTTPS Documentation](https://nodejs.org/api/https.html)
+- [OpenSSL Certificate Generation](https://www.openssl.org/docs/man1.1.1/man1/req.html)
+- [MDN Web Docs - SSL/TLS](https://developer.mozilla.org/en-US/docs/Glossary/SSL)
+- [RFC 5280 - Certificate Standards](https://tools.ietf.org/html/rfc5280)
+- [Unicode Emoji Reference](https://unicode.org/emoji/charts/full-emoji-list.html)

package/reports/31-12-2025_21-15.md

@@ -0,0 +1,29 @@
+# Relatório de Modificação - Log Estilo Vite
+
+**Data:** 31-12-2025
+**Tarefa:** Customizar o log de inicialização do `hot-server` para ser idêntico ao do Vite.
+
+## O que foi feito
+
+- Refatorado o método `start()` na classe `HotServer` em `src/server.ts`.
+- Implementada a detecção de interfaces de rede usando o módulo nativo `node:os`.
+- Adicionada medição de tempo de inicialização (`startTime`) para exibir "ready in X ms".
+- Estilização completa usando códigos de escape ANSI para cores e negrito, imitando perfeitamente o visual premium do Vite.
+- Substituído o nome "VITE" por "HOT-SERVER".
+- Adicionado o link de ajuda "press h + enter to show help".
+- Atualizado o feedback de porta em uso para também seguir o padrão visual.
+- Corrigido o `.gitignore` para incluir a pasta `dist`.
+- Incrementada a versão do projeto para `0.3.1`.
+
+## Por que foi feito
+
+- Para melhorar a experiência do desenvolvedor (DX), fornecendo um feedback visual familiar e profissional.
+- Para facilitar o acesso ao servidor a partir de outros dispositivos na mesma rede (exibindo IPs de Network).
+- Para alinhar o projeto com as melhores práticas de estética moderna solicitadas pelo usuário.
+
+## Como testar
+
+1. Execute `bun run dev` ou `bun run src/index.ts`.
+2. Observe o log de inicialização formatado no terminal.
+3. Verifique se as URLs Local e Network estão corretas e acessíveis.
+4. Tente iniciar o servidor em uma porta já ocupada para ver o novo log de fallback.

package/reports/31-12-2025_21-45.md

@@ -0,0 +1,19 @@
+# Relatório de Modificação - Porta Padrão
+
+**Data:** 31-12-2025
+**Tarefa:** Alterar a porta padrão do `hot-server` para 6000.
+
+## O que foi feito
+
+- Alterado o valor padrão de `port` em `src/index.ts` de `9999` para `6000`.
+- Incrementada a versão do projeto para `0.3.2`.
+- Atualizado o `CHANGELOG.md`.
+
+## Por que foi feito
+
+- Atender à solicitação do usuário de padronizar a porta de execução para 6000.
+
+## Como testar
+
+1. Execute `bun run src/index.ts`.
+2. Verifique se o log exibe `http://localhost:6000/` por padrão.

package/reports/31-12-2025_22-00.md

@@ -0,0 +1,31 @@
+# Relatório de Modificação - Implementação do Deployer Interativo
+
+**Data:** 31-12-2025
+**Tarefa:** Substituir o script `cria.sh` por um comando `deploy` interativo integrado ao CLI do `hot-server`.
+
+## O que foi feito
+
+- Criada a classe `Deployer` em `src/deployer.ts` para gerenciar o processo de deploy.
+- Implementada uma interface de linha de comando (CLI) interativa e visualmente "premium" usando `readline` e códigos ANSI.
+- Automatizada a criação de configurações do Nginx (proxy reverso e suporte a WebSocket).
+- Automatizado o uso do Certbot para geração de certificados SSL.
+- Adicionada geração automática do comando de inicialização PM2 com nomes baseados no domínio/subdomínio.
+- Integrado o novo comando no `src/index.ts` detectando o argumento `deploy`.
+- Renomeado `cria.sh` para `APAGAR_cria.sh` (indicando depreciação).
+- Incrementada versão para `0.4.0` e atualizado `CHANGELOG.md`.
+
+## Por que foi feito
+
+- Para oferecer uma experiência de deploy profissional e segura, eliminando a manipulação manual de scripts Shell.
+- Para simplificar o fluxo de deploy em produção (Nginx + SSL + PM2) com um único comando Wizard.
+- Para atender ao requisito de interface "bonita" e interativa no terminal.
+
+## Como testar
+
+1. Compile o projeto: `bun run build`.
+2. Execute o deployer (simulação): `bun run src/index.ts deploy`.
+3. Siga as instruções interativas no terminal.
+   - Digite um domínio (ex: `app.teste.com`).
+   - Confirme a porta (default `6000`).
+   - Observe o comando PM2 gerado.
+   - (Opcional) Confirme a configuração do Nginx (requer `sudo` e ambiente compatível).