@archznn/xavva 1.6.5 → 1.8.0

package/README.md

@@ -1,75 +1,111 @@
-# XAVVA 🚀 (Windows Only) `v1.6.5`
+# XAVVA 🚀 (Windows Only) `v1.8.0`
 
 Xavva é uma CLI de alto desempenho construída com **Bun** para automatizar o ciclo de desenvolvimento de aplicações Java (Maven/Gradle) rodando no Apache Tomcat. Ela foi desenhada especificamente para desenvolvedores que buscam a velocidade de ambientes modernos (como Node.js/Vite) dentro do ecossistema Java Enterprise.
 
-> [!IMPORTANT]
-> **Compatibilidade:** Atualmente, o Xavva é exclusivo para **Windows**, utilizando integrações nativas com PowerShell e CMD para automação de browser e gerenciamento de processos.
+---
+
+## 🛠️ Por que Xavva?
+
+Desenvolver para Java/Tomcat tradicionalmente envolve ciclos lentos de `clean install`, `war deploy` e restarts de servidor. O Xavva quebra esse paradigma ao introduzir um fluxo de **Hot-Reload incremental**, onde apenas o que mudou é enviado ao servidor.
 
-## 🛠️ Funcionalidades de Elite
+### ⚡ Funcionalidades de Elite
 
-- **⚡ Ultra-Fast Hot Swap**: Compilação incremental e injeção direta de arquivos `.class` e recursos (JSP, HTML, CSS, JS) no Tomcat em execução sem necessidade de restart.
-- **🛠️ Modo Dev Inteligente**: O comando `xavva dev` ativa hot-reload, logs limpos, debugger (JPDA) e monitoramento de memória em um único fluxo.
-- **🌐 Live Reload Automático**: Atualiza automaticamente as abas do Chrome ou Edge após o deploy ou sincronização de arquivos, mantendo o foco no código.
-- **🔍 API Documentation (Swagger-like)**: O comando `xavva docs` mapeia estaticamente sua API, exibindo endpoints, métodos HTTP e parâmetros (Query, Path, Body) diretamente no terminal.
-- **📊 Real-time Log Filtering**: Filtra ruídos excessivos do Tomcat/Jersey/SLF4J, destacando erros Java com dicas de solução e tempo de startup.
-- **📈 JVM & Memory Monitor**: Exibe o consumo de RAM (Working Set) do processo do Tomcat em tempo real.
-- **🩺 Doctor Mode**: Diagnostica o ambiente (Java, Tomcat, Maven, Gradle) e corrige automaticamente problemas de **Encoding (UTF-8 BOM)** que podem causar falhas silenciosas no Java.
-- **🛡️ JAR Audit**: O comando `xavva audit` analisa todas as dependências (`.jar`) da sua aplicação e verifica vulnerabilidades conhecidas (CVEs) usando o banco de dados **OSV.dev**.
+- **Ultra-Fast Hot Swap**: Compilação incremental e injeção direta de arquivos `.class` e recursos (JSP, HTML, CSS, JS) no Tomcat em execução sem restart.
+- **Gradle & Maven Native**: Suporte robusto para ambos os ecossistemas, incluindo extração automática de classpath para execução de classes standalone (`run`/`debug`).
+- **DCEVM Integration**: O Xavva pode baixar e configurar automaticamente uma JDK com DCEVM (JetBrains Runtime), permitindo mudanças estruturais em classes (novos métodos/campos) em tempo real.
+- **API Documentation (Swagger-like)**: Mapeamento estático de endpoints, métodos HTTP e parâmetros diretamente no terminal via `xavva docs`.
+- **Live Reload Automático**: Sincronização inteligente que atualiza o browser (Chrome/Edge) após mudanças em JSPs ou recursos estáticos.
+- **Segurança & Robustez**: Auditoria de dependências (`.jar`) e execução protegida contra *Command Injection* no PowerShell.
+- **Pathing JAR (Windows)**: Contorna limites de caracteres do Windows em classpaths gigantes através de geração dinâmica de Manifestos compatíveis com a especificação Java.
+- **Auto-Healing**: Diagnóstico e reparo automático de problemas comuns de ambiente, como encoding UTF-8 com BOM.
+
+---
 
-## 🚀 Instalação e Uso
+## 🚀 Começo Rápido
 
-Você pode instalar o Xavva globalmente usando o NPM (requer [Bun](https://bun.sh/) instalado no sistema):
+### Pré-requisitos
+- **Windows** (Otimizado para PowerShell Core e Windows PowerShell)
+- **Bun** instalado (`powershell -c "irm bun.sh/install.ps1 | iex"`)
+- **Tomcat** configurado via variável de ambiente `TOMCAT_HOME` ou `CATALINA_HOME`.
 
-```bash
-# Instalação global
+### Instalação
+```powershell
+# Instalação global via NPM
 npm install -g @archznn/xavva
 
-# Ou rodar sem instalar via npx
+# Ou use diretamente via npx
 npx @archznn/xavva dev
 ```
 
-## ⚙️ Zero Config & Auto-Detection
+---
 
-O Xavva foi evoluído para um modelo **Zero Config**. Você não precisa mais de arquivos de configuração para começar.
+## 📖 Referência de Comandos
 
-- **Auto-Detecção:** O Xavva identifica automaticamente se seu projeto usa **Maven** (`pom.xml`) ou **Gradle** (`build.gradle`) ao ser executado na raiz.
-- **Ambiente Inteligente:** Ele utiliza as variáveis de ambiente `TOMCAT_HOME` ou `CATALINA_HOME` para localizar o servidor.
-- **Prioridade CLI:** Qualquer parâmetro passado via linha de comando (como `--path` ou `--port`) tem precedência total sobre o ambiente.
+O Xavva utiliza uma arquitetura modular de comandos e serviços, garantindo alta performance e extensibilidade.
 
-### Comandos Principais
+### 1. Modo Desenvolvimento (`xavva dev`)
+O comando principal para o dia a dia. Ativa o monitoramento de arquivos e o Hot-Reload.
+  - **O que faz**: Compila Java, sincroniza recursos, limpa logs, inicia o Tomcat e monitora mudanças.
+- **Flags úteis**: 
+  - `--no-build`: Pula o build inicial.
+  - `--watch`: Ativa o modo de observação de arquivos (padrão em `dev`).
+  - `--port 8081`: Define uma porta específica para o Tomcat.
+  - `--dp 9000`: Altera a porta do Debugger (JPDA) (padrão 5005).
 
-```bash
-# Inicia o modo de desenvolvimento completo (Auto-detecta Maven/Gradle)
-xavva dev
+### 2. Execução de Classes (`xavva run` / `xavva debug`)
+Executa classes Java standalone (`public static void main`) com resolução automática de dependências Maven ou Gradle.
+- **Inteligência de Classpath**: Gera automaticamente um `classpath.jar` temporário (Pathing JAR) para evitar o erro de "Command line too long" no Windows.
+- **Busca por Grep**: Se você fornecer apenas parte do nome da classe, o Xavva a encontrará recursivamente no projeto.
 
-# Define o Tomcat e o Profile manualmente via CLI
-xavva dev -p C:\tomcat-9 -P production
+### 3. Documentação de API (`xavva docs`)
+Gera uma documentação instantânea dos seus controladores Jersey/Spring no terminal.
+- Mostra a URL completa, método HTTP e parâmetros (Path, Query, Body).
 
-# Exibe a documentação da API
-xavva docs
+### 4. Diagnóstico e Reparo (`xavva doctor`)
+Verifica se o seu ambiente está saudável.
+- **`xavva doctor --fix`**:
+  - Instala o **JetBrains Runtime (DCEVM)** se necessário.
+  - Remove automaticamente o **BOM (Byte Order Mark)** de arquivos Java que causam erros de compilação.
+  - Configura o `JAVA_HOME` do sistema.
 
-# Audita vulnerabilidades nas dependências JAR do app
-xavva audit
+### 5. Auditoria de Segurança (`xavva audit`)
+Analisa a pasta `WEB-INF/lib` em busca de JARs vulneráveis via integração com **OSV.dev**. Essencial para manter a integridade do projeto antes de deploys em produção.
 
-# Diagnostica o ambiente e limpa arquivos com BOM (UTF-8 signature)
-xavva doctor --fix
-```
+### 6. Logs em Tempo Real (`xavva logs`)
+Exibe os logs do Tomcat filtrando ruídos excessivos e destacando StackTraces importantes. Use `--grep "NomeDaClasse"` para focar em logs específicos.
+
+---
 
-### Opções Úteis
+## 🏗️ Arquitetura do Sistema
 
-- `-p, --path <path>`: Caminho customizado do Tomcat (Sobrescreve TOMCAT_HOME).
-- `-P, --profile <nome>`: Define o profile do Maven/Gradle (ex: dev, prod).
-- `-t, --tool <maven|gradle>`: Força o uso de uma ferramenta específica.
-- `-n, --name <nome>`: Define o nome do contexto da aplicação.
-- `-w, --watch`: Ativa o monitoramento de arquivos para hot-reload.
-- `-d, --debug`: Habilita o Java Debugger na porta 5005.
+O Xavva foi refatorado para uma arquitetura de **Injeção de Dependências** e **Serviços Centralizados**:
+
+- **CommandRegistry**: Gerenciamento modular de comandos via Command Pattern.
+- **ProjectService**: Inteligência centralizada para descoberta de diretórios de build, artefatos e classpaths Java.
+- **AuditService**: Segurança aprimorada com execução isolada e protegida no PowerShell.
+- **TomcatService**: Gerenciamento do ciclo de vida do servidor com suporte a hotswap dinâmico.
+
+---
+
+## ⚙️ Configuração (Zero Config)
+
+O Xavva funciona sem arquivos de configuração externos, baseando-se no ambiente:
+
+| Variável | Descrição |
+|----------|-----------|
+| `TOMCAT_HOME` | Caminho raiz do seu Apache Tomcat. |
+| `JAVA_HOME` | JDK utilizada para compilação e execução. |
+
+**Dica**: O Xavva cria automaticamente uma pasta `.xavva` no seu projeto para cache e artefatos temporários, e a adiciona ao seu `.gitignore`.
+
+---
 
-## 📦 Stack Tecnológica
+## 🧩 Sincronização de Recursos
 
-- **Runtime:** [Bun](https://bun.sh/) (Engine de alta performance)
-- **Linguagem:** [TypeScript](https://www.typescriptlang.org/)
-- **Automação:** PowerShell & CMD (Integração nativa Windows)
-- **CI/CD:** GitHub Actions para geração de binários multi-plataforma (via Bun Compile)
+Ao editar um arquivo, o Xavva decide a melhor estratégia:
+- **`.java`**: Compila apenas a classe e injeta o bytecode via `fastSync`.
+- **`.jsp` / `.html` / `.css`**: Sincroniza o arquivo diretamente na pasta de deploy do Tomcat.
+- **`pom.xml` / `build.gradle`**: Identifica mudanças estruturais e sugere um rebuild completo com invalidação de cache inteligente.
 
 ---
-*Desenvolvido para transformar a experiência de desenvolvimento Java Legacy em algo ágil e produtivo.*
+*Desenvolvido para transformar o legado em produtivo. 🚀*

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "1.6.5",
+	"version": "1.8.0",
 	"description": "Ultra-fast CLI tool for Java/Tomcat development on Windows with Hot-Reload and Zero Config.",
 	"module": "src/index.ts",
 	"type": "module",

package/src/commands/AuditCommand.ts

@@ -1,22 +1,22 @@
 import path from "path";
 import fs from "fs";
 import type { Command } from "./Command";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments } from "../types/config";
 import { AuditService, type JarAuditResult } from "../services/AuditService";
 import { Logger } from "../utils/ui";
 
 export class AuditCommand implements Command {
-    async execute(config: AppConfig): Promise<void> {
+    constructor(private auditService: AuditService) {}
+
+    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
         Logger.section("Vulnerability & JAR Audit");
 
-        let appName = config.project.appName;
+        let appName = args?.name || config.project.appName;
         
-        // 1. Tentar inferir do diretório atual se não foi passado via config
         if (!appName) {
             appName = this.inferFromArtifacts();
         }
 
-        // 2. Se ainda não tem nome, tenta inferir do Tomcat
         if (!appName) {
             const webappsPath = path.join(config.tomcat.path, "webapps");
             if (fs.existsSync(webappsPath)) {
@@ -40,10 +40,8 @@ export class AuditCommand implements Command {
             return;
         }
 
-        const auditService = new AuditService(config.tomcat);
-        
         try {
-            const results = await auditService.runAudit(appName);
+            const results = await this.auditService.runAudit(appName);
             const vulnerable = results.filter(r => r.vulnerabilities.length > 0);
 
             if (vulnerable.length === 0) {
@@ -68,14 +66,12 @@ export class AuditCommand implements Command {
     }
 
     private inferFromArtifacts(): string | undefined {
-        // Busca .war no target (Maven) ou build/libs (Gradle)
         const paths = ["target", "build/libs"];
         for (const p of paths) {
             const fullPath = path.join(process.cwd(), p);
             if (fs.existsSync(fullPath)) {
                 const wars = fs.readdirSync(fullPath).filter(f => f.endsWith(".war"));
                 if (wars.length > 0) {
-                    // Retorna o nome do .war mais recente sem a extensão
                     const latest = wars.map(name => ({
                         name,
                         time: fs.statSync(path.join(fullPath, name)).mtimeMs

package/src/commands/BuildCommand.ts

@@ -4,15 +4,15 @@ import { BuildService } from "../services/BuildService";
 import { Logger } from "../utils/ui";
 
 export class BuildCommand implements Command {
+    constructor(private buildService: BuildService) {}
+
     async execute(config: AppConfig): Promise<void> {
-        const builder = new BuildService(config.project, config.tomcat);
-        
         Logger.section("Build Only");
         Logger.info("Tool", config.project.buildTool.toUpperCase());
         if (config.project.profile) Logger.info("Profile", config.project.profile);
         
         try {
-            await builder.runBuild();
+            await this.buildService.runBuild();
             Logger.success("Build completed successfully!");
         } catch (error: any) {
             Logger.error(error.message);

package/src/commands/Command.ts

@@ -1,5 +1,5 @@
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments } from "../types/config";
 
 export interface Command {
-    execute(config: AppConfig): Promise<void>;
+    execute(config: AppConfig, args?: CLIArguments): Promise<void>;
 }

package/src/commands/CommandRegistry.ts

@@ -0,0 +1,36 @@
+import type { AppConfig, CLIArguments } from "../types/config";
+import type { Command } from "./Command";
+import { Logger } from "../utils/ui";
+import { HelpCommand } from "./HelpCommand";
+
+export class CommandRegistry {
+    private commands = new Map<string, Command>();
+
+    register(name: string, command: Command) {
+        this.commands.set(name, command);
+    }
+
+    has(name: string): boolean {
+        return this.commands.has(name);
+    }
+
+    get(name: string): Command | undefined {
+        return this.commands.get(name);
+    }
+
+    async execute(name: string, config: AppConfig, args: CLIArguments) {
+        const command = this.commands.get(name);
+        if (!command) {
+            Logger.error(`Comando desconhecido: ${name}`);
+            await new HelpCommand().execute(config);
+            process.exit(1);
+        }
+
+        try {
+            await command.execute(config, args);
+        } catch (error: any) {
+            Logger.error(`Erro ao executar comando '${name}': ${error.message}`);
+            process.exit(1);
+        }
+    }
+}

package/src/commands/DeployCommand.ts

@@ -1,159 +1,235 @@
 import path from "path";
 import fs from "fs";
 import type { Command } from "./Command";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments } from "../types/config";
 import { BuildService } from "../services/BuildService";
 import { TomcatService } from "../services/TomcatService";
 import { Logger } from "../utils/ui";
 import { EndpointService } from "../services/EndpointService";
+import { BrowserService } from "../services/BrowserService";
 
 export class DeployCommand implements Command {
-    constructor(private tomcat?: TomcatService, private builder?: BuildService) {}
+    constructor(private tomcat: TomcatService, private builder: BuildService) {}
 
-    private async reloadBrowser(url: string) {
-        if (process.platform !== 'win32') return;
-        
-        await new Promise(r => setTimeout(r, 800));
-
-        const psCommand = `
-            $shell = New-Object -ComObject WScript.Shell
-            $process = Get-Process | Where-Object { $_.MainWindowTitle -match "Chrome" -or $_.MainWindowTitle -match "Edge" } | Select-Object -First 1
-            if ($process) {
-                $shell.AppActivate($process.Id)
-                Sleep -m 100
-                $shell.SendKeys("{F5}")
-            }
-        `;
-        Bun.spawn(["powershell", "-command", psCommand]);
-    }
-
-    async execute(config: AppConfig, incremental = false, isWatching = false): Promise<void> {
-        const tomcat = this.tomcat || new TomcatService(config.tomcat);
-        const builder = this.builder || new BuildService(config.project, config.tomcat);
+    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
+        const incremental = args?.watch && args?.incremental;
+        const isWatching = !!args?.watch;
+        const tomcat = this.tomcat;
+        const builder = this.builder;
 
         if (!incremental) {
-            Logger.section("Deploy Configuration");
-            if (config.project.quiet) {
-                Logger.info("App", `${config.project.appName} (${config.project.buildTool.toUpperCase()}${config.project.profile ? ` - ${config.project.profile}` : ""})`);
-                Logger.info("Status", `Watch: ${isWatching ? "ON" : "OFF"} | Debug: ${config.project.debug ? "ON" : "OFF"}`);
-            } else {
-                Logger.info("Tool", config.project.buildTool.toUpperCase());
-                Logger.info("App Name", config.project.appName);
-                if (config.project.profile) Logger.info("Profile", config.project.profile);
-                Logger.info("Watch Mode", isWatching ? "Active" : "Inactive");
-                Logger.info("Debug Mode", config.project.debug ? "Active" : "Inactive");
-            }
-
-            const srcPath = path.join(process.cwd(), "src");
-            if (fs.existsSync(srcPath)) {
-                const contextPath = (config.project.appName || "").replace(".war", "");
-                const endpoints = EndpointService.scan(srcPath, contextPath);
-                if (endpoints.length > 0) {
-                    Logger.info("Endpoints", endpoints.length);
-                }
-            }
+            this.logConfiguration(config, isWatching);
         } else {
-            console.log("");
-            Logger.warn("Re-deploying detected changes...");
+            Logger.watcher("Change detected", "change");
         }
         
         try {
             const contextPath = (config.project.appName || "").replace(".war", "");
 
             if (!incremental) {
-                await tomcat.killConflict();
-            }
+                tomcat.clearWebapps(contextPath);
 
-            if (!config.project.skipBuild) {
-                await builder.runBuild(incremental);
+                const buildTask = config.project.skipBuild ? Promise.resolve() : builder.runBuild(incremental);
+                const killTask = tomcat.killConflict();
+                
+                if (!config.project.skipBuild) {
+                    Logger.watcher("Preparing environment and building in parallel", "start");
+                }
+
+                await Promise.all([buildTask, killTask]);
+                
+                if (!config.project.skipBuild) {
+                    Logger.build("Full project build and environment ready");
+                }
+            } else {
+                if (!config.project.skipBuild) {
+                    Logger.watcher("Incremental compilation", "start");
+                    await builder.runBuild(incremental);
+                }
             }
 
             if (incremental) {
-                const appFolder = await builder.syncClasses();
-                const actualContextPath = contextPath || appFolder || "";
-                if (actualContextPath) {
-                    const actualAppUrl = `http://localhost:${config.tomcat.port}/${actualContextPath}`;
-                    await this.reloadBrowser(actualAppUrl);
-                }
+                const actualAppFolder = await builder.syncClasses(); 
+                const actualContextPath = contextPath || actualAppFolder || "";
+                const actualAppUrl = `http://localhost:${config.tomcat.port}/${actualContextPath}`;
+                await BrowserService.reload(actualAppUrl);
+                Logger.watcher("Redeploy completed", "success");
                 return;
             }
 
-            Logger.step("Cleaning webapps and cache");
-            tomcat.clearWebapps();
-
-            Logger.step("Moving artifacts to webapps");
-            const artifact = await builder.deployToWebapps();
-            
-            const finalContextPath = contextPath || artifact.replace(".war", "");
-            const finalAppUrl = `http://localhost:${config.tomcat.port}/${finalContextPath}`;
+            Logger.build("Webapps cleaned");
+            const artifactInfo = await builder.deployToWebapps();
+            Logger.build("Artifacts generated");
             
-            tomcat.onReady = async () => {
-                Logger.step(`Checking health at ${finalAppUrl}`);
-                
-                try {
-                    await new Promise(r => setTimeout(r, 1500));
-                    
-                    const response = await fetch(finalAppUrl);
-                    if (response.status < 500) {
-                        const memory = await tomcat.getMemoryUsage();
-                        Logger.success(`App is UP! (Status: ${response.status} | RAM: ${memory})`);
-
-                        if (!config.project.quiet) {
-                            const endpoints = EndpointService.scan(path.join(process.cwd(), "src"), finalContextPath);
-                            if (endpoints.length > 0) {
-                                console.log(`\n  ${"\x1b[36m"}◈ ENDPOINT MAP:${"\x1b[0m"}`);
-                                endpoints.forEach(e => console.log(`    ${"\x1b[90m"}➜${"\x1b[0m"} http://localhost:${config.tomcat.port}${e.fullPath}`));
-                                console.log("");
-                            }
-                        }
-                        
-                        if (incremental) {
-                            await this.reloadBrowser(finalAppUrl);
-                        } else {
-                            if (process.platform === 'win32') {
-                                Bun.spawn(["cmd", "/c", "start", finalAppUrl]);
-                            } else {
-                                const start = process.platform === 'darwin' ? 'open' : 'xdg-open';
-                                Bun.spawn([start, finalAppUrl]);
+            const finalContextPath = contextPath || artifactInfo.finalName.replace(".war", "");
+            const appWebappPath = path.join(config.tomcat.path, "webapps", finalContextPath);
+
+            if (artifactInfo.isDirectory) {
+                await builder.syncClasses(artifactInfo.path);
+                Logger.build("Exploded directory synced");
+            } else {
+                if (!fs.existsSync(appWebappPath)) fs.mkdirSync(appWebappPath, { recursive: true });
+
+                const artifactStat = fs.statSync(artifactInfo.path);
+                const webappStat = fs.existsSync(appWebappPath) ? fs.statSync(appWebappPath) : null;
+
+                if (!webappStat || artifactStat.mtimeMs > webappStat.mtimeMs) {
+                    try {
+                        Bun.spawnSync(["jar", "xf", artifactInfo.path], { cwd: appWebappPath });
+                        Logger.build("Artifacts deployed");
+                    } catch (e) {
+                        const extractCmd = `Expand-Archive -Path $env:ARTIFACT_PATH -DestinationPath $env:DEST_PATH -Force`;
+                        Bun.spawnSync(["powershell", "-command", extractCmd], {
+                            env: {
+                                ...process.env,
+                                ARTIFACT_PATH: artifactInfo.path,
+                                DEST_PATH: appWebappPath
                             }
-                        }
-                    } else {
-                        Logger.warn(`App is starting, but returned status ${response.status}. Check your logs.`);
+                        });
+                        Logger.build("Artifacts deployed (legacy mode)");
                     }
-                } catch (e) {
-                    Logger.error(`Health check failed: Could not connect to ${finalAppUrl}`);
+                } else {
+                    Logger.build("Webapp already up to date, skipping extraction");
                 }
+            }
+
+            this.injectHotswapProperties(appWebappPath);
+
+            const finalAppUrl = `http://localhost:${config.tomcat.port}/${finalContextPath}`;
+            
+            tomcat.onReady = async () => {
+                await this.handleServerReady(config, finalAppUrl, finalContextPath, tomcat, incremental);
             };
 
-            tomcat.start(config.project.cleanLogs, config.project.debug, config.project.skipScan, config.project.quiet);
+            tomcat.start(config, isWatching);
         } catch (error: any) {
             Logger.error(error.message);
             throw error;
         }
     }
 
+    private logConfiguration(config: AppConfig, isWatching: boolean) {
+        Logger.config("Runtime", config.project.buildTool.toUpperCase());
+        Logger.config("Watch Mode", isWatching ? "ON" : "OFF");
+        Logger.config("Debug", config.project.debug ? `ON (Port ${config.project.debugPort})` : "OFF");
+
+        let javaBin = "java";
+        if (process.env.JAVA_HOME) {
+            const homeBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
+            if (fs.existsSync(homeBin)) javaBin = homeBin;
+        }
+        
+        const javaVer = Bun.spawnSync([javaBin, "-version"]);
+        const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
+        const hasDcevm = ["dcevm", "jetbrains", "trava", "jbr"].some(v => output.includes(v));
+        
+        if (!hasDcevm && isWatching) {
+            Logger.config("Hot Reload", "Standard (No structural changes)");
+        } else if (hasDcevm) {
+            Logger.config("Hot Reload", "Advanced (DCEVM Active)");
+        }
+
+        const srcPath = path.join(process.cwd(), "src");
+        if (fs.existsSync(srcPath)) {
+            const contextPath = (config.project.appName || "").replace(".war", "");
+            const endpoints = EndpointService.scan(srcPath, contextPath);
+            if (endpoints.length > 0) {
+                Logger.config("Endpoints", endpoints.length);
+            }
+        }
+    }
+
+    private injectHotswapProperties(appWebappPath: string) {
+        const webInfClassesDir = path.join(appWebappPath, "WEB-INF", "classes");
+        if (!fs.existsSync(webInfClassesDir)) fs.mkdirSync(webInfClassesDir, { recursive: true });
+        
+        const xavvaProps = path.join(process.cwd(), ".xavva", "hotswap-agent.properties");
+        if (fs.existsSync(xavvaProps)) {
+            fs.copyFileSync(xavvaProps, path.join(webInfClassesDir, "hotswap-agent.properties"));
+        }
+    }
+
+    private async handleServerReady(config: AppConfig, url: string, context: string, tomcat: TomcatService, incremental: boolean) {
+        try {
+            await new Promise(r => setTimeout(r, 1500));
+            const response = await fetch(url);
+            if (response.status < 500) {
+                const memory = await tomcat.getMemoryUsage();
+                Logger.health(url, "success");
+                Logger.health(`Status ${response.status}`, "success");
+                Logger.health(`Memory ${memory}`, "success");
+
+                if (!config.project.quiet) {
+                    this.showEndpointMap(config.tomcat.port, context);
+                }
+                
+                if (incremental) {
+                    await BrowserService.reload(url);
+                } else {
+                    BrowserService.open(url);
+                }
+            } else {
+                Logger.health(`App returned status ${response.status}`, "warn");
+            }
+        } catch (e) {
+            Logger.health(`Could not connect to ${url}`, "error");
+        }
+    }
+
+    private showEndpointMap(port: number, context: string) {
+        const endpoints = EndpointService.scan(path.join(process.cwd(), "src"), context);
+        if (endpoints.length > 0) {
+            Logger.newline();
+            Logger.log(`${Logger.C.cyan}◈ ENDPOINT MAP:${Logger.C.reset}`);
+            
+            const apis = endpoints.filter(e => e.className !== "JSP");
+            const jsps = endpoints.filter(e => e.className === "JSP");
+
+            if (apis.length > 0) {
+                const uniqueApiUrls = [...new Set(apis.map(e => `http://localhost:${port}${e.fullPath}`))];
+                uniqueApiUrls.forEach(url => Logger.log(`${Logger.C.dim}➜ ${Logger.C.reset}${url}`));
+            }
+
+            if (jsps.length > 0) {
+                Logger.log(`${Logger.C.dim}--- JSPs ---${Logger.C.reset}`);
+                const uniqueJspUrls = [...new Set(jsps.map(e => `http://localhost:${port}${e.fullPath}`))];
+                uniqueJspUrls.forEach(url => Logger.log(`${Logger.C.dim}📄 ${Logger.C.reset}${url}`));
+            }
+        }
+    }
+
     async syncResource(config: AppConfig, filename: string): Promise<void> {
-        const appName = config.project.appName || "";
-        const explodedPath = path.join(config.tomcat.path, "webapps", appName);
+        const contextPath = (config.project.appName || "").replace(".war", "");
+        const webappsPath = path.join(config.tomcat.path, "webapps");
+        let appFolder = contextPath;
         
-        if (!fs.existsSync(explodedPath)) {
-            return;
+        if (!appFolder && fs.existsSync(webappsPath)) {
+            const folders = fs.readdirSync(webappsPath, { withFileTypes: true })
+                .filter(dirent => dirent.isDirectory() && !["ROOT", "manager", "host-manager", "docs"].includes(dirent.name));
+            if (folders.length === 1) appFolder = folders[0].name;
         }
 
+        const explodedPath = path.join(webappsPath, appFolder);
+        if (!appFolder || !fs.existsSync(explodedPath)) return;
+
         const parts = filename.split(/[/\\]/);
         const webappIndex = parts.indexOf("webapp");
+        const webContentIndex = parts.indexOf("WebContent");
+        const rootIndex = webappIndex !== -1 ? webappIndex : webContentIndex;
         
-        if (webappIndex !== -1) {
-            const relPath = parts.slice(webappIndex + 1).join(path.sep);
+        if (rootIndex !== -1) {
+            const relPath = parts.slice(rootIndex + 1).join(path.sep);
             const targetPath = path.join(explodedPath, relPath);
             
             try {
+                const targetDir = path.dirname(targetPath);
+                if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+
                 fs.copyFileSync(filename, targetPath);
                 if (!config.project.quiet) Logger.success(`Synced ${path.basename(filename)} directly to Tomcat!`);
                 
-                const contextPath = config.project.appName || "";
-                const appUrl = `http://localhost:${config.tomcat.port}/${contextPath}`;
-                await this.reloadBrowser(appUrl);
+                const appUrl = `http://localhost:${config.tomcat.port}/${appFolder}`;
+                await BrowserService.reload(appUrl);
             } catch (e) {
                 Logger.error(`Failed to sync resource: ${filename}`);
             }