@archznn/xavva 2.2.2 → 2.3.0

package/README.md

@@ -2,7 +2,7 @@
 
 > Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows
 
-[![Version](https://img.shields.io/badge/version-2.2.2-blue.svg)](https://github.com/leorsousa05/Xavva)
+[![Version](https://img.shields.io/badge/version-2.3.0-blue.svg)](https://github.com/leorsousa05/Xavva)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
 Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomcat development experience. It brings modern development workflows (like Node.js/Vite) to the Java Enterprise ecosystem with hot-reload, smart logging, and automated deployment.
@@ -18,6 +18,8 @@ Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomc
 - 📦 **Dependency Analysis** — Detect conflicts and outdated dependencies
 - 🎯 **Maven & Gradle** — Native support for both build tools
 - 🔧 **Auto-Healing** — Automatic diagnosis and repair of common issues
+- 🐱 **Embedded Tomcat** — Auto-install Tomcat, no manual setup needed
+- 📦 **WAR Generation** — Build as .war file or exploded directory
 
 ---
 
@@ -42,6 +44,9 @@ xavva dev --tui
 # Deploy to Tomcat
 xavva deploy
 
+# Build and deploy as .war file
+xavva deploy --war
+
 # Analyze dependencies for issues
 xavva deps
 
@@ -50,6 +55,9 @@ xavva deps --update-safe
 
 # Check for security vulnerabilities
 xavva audit
+
+# Use embedded Tomcat (auto-install)
+xavva dev --yes
 ```
 
 ---
@@ -82,6 +90,30 @@ xavva audit
 | `xavva doctor`   | Diagnose environment issues (JAVA_HOME, DCEVM)            |
 | `xavva profiles` | List available Maven/Gradle profiles                      |
 | `xavva docs`     | Generate endpoint documentation                           |
+| `xavva tomcat`   | Manage embedded Tomcat installations                      |
+
+---
+
+## 🐱 Embedded Tomcat
+
+Xavva can automatically download and manage a Tomcat installation for you:
+
+```bash
+# First time usage - auto-install Tomcat
+xavva dev --yes
+
+# Or install manually
+xavva tomcat install
+
+# Check Tomcat status
+xavva tomcat status
+
+# List available versions
+xavva tomcat list
+
+# Use specific version
+xavva dev --tomcat-version 9.0.115
+```
 
 ---
 
@@ -176,6 +208,9 @@ Create `xavva.json` in your project root:
 | `-d, --debug`          | Enable JPDA debugger            |
 | `-c, --clean`          | Clean logs before start         |
 | `-s, --no-build`       | Skip initial build              |
+| `-W, --war`            | Generate .war file (vs exploded)|
+| `--cache`              | Use build cache (faster)        |
+| `-y, --yes`            | Auto-install Tomcat (no prompt) |
 | `-V, --verbose`        | Detailed output                 |
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.2.2",
+	"version": "2.3.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/DepsCommand.ts

@@ -34,7 +34,7 @@ export class DepsCommand implements Command {
 				Logger.log("  • Arquivo pom.xml/build.gradle não encontrado");
 				Logger.log("  • Erro de parsing no arquivo de configuração");
 				Logger.newline();
-				Logger.log(`${Logger.C.cyan}Dica:${Logger.C.reset} Execute com --verbose para mais detalhes`);
+				Logger.log(`${Logger.C.primary}Dica:${Logger.C.reset} Execute com --verbose para mais detalhes`);
 				return;
 			}
 
@@ -87,7 +87,7 @@ export class DepsCommand implements Command {
 		Logger.section("Sugestões de Correção");
 
 		for (const conflict of result.conflicts) {
-			Logger.log(`\n${Logger.C.cyan}${conflict.groupId}:${conflict.artifactId}${Logger.C.reset}`);
+			Logger.log(`\n${Logger.C.primary}${conflict.groupId}:${conflict.artifactId}${Logger.C.reset}`);
 			
 			if (buildTool === "maven") {
 				Logger.log("  Adicione ao pom.xml:");
@@ -143,7 +143,7 @@ export class DepsCommand implements Command {
 
 				Logger.newline();
 				Logger.log(`${Logger.C.warning}⚠️  Execute 'xavva build' para compilar e aplicar as mudanças${Logger.C.reset}`);
-				Logger.log(`${Logger.C.cyan}💡 Dica:${Logger.C.reset} Execute 'xavva audit' para verificar vulnerabilidades nas novas versões`);
+				Logger.log(`${Logger.C.primary}💡 Dica:${Logger.C.reset} Execute 'xavva audit' para verificar vulnerabilidades nas novas versões`);
 			} else {
 				Logger.warn("Nenhuma dependência foi atualizada");
 			}

package/src/commands/DoctorCommand.ts

@@ -31,7 +31,7 @@ export class DoctorCommand implements Command {
 				await this.installDCEVM();
 			} else {
 				Logger.log(
-					`    ${Logger.C.cyan}Use 'xavva doctor --fix' para baixar uma JDK com DCEVM integrado.${Logger.C.reset}`,
+					`    ${Logger.C.primary}Use 'xavva doctor --fix' para baixar uma JDK com DCEVM integrado.${Logger.C.reset}`,
 				);
 			}
 		}

package/src/commands/HelpCommand.ts

@@ -28,9 +28,10 @@ export class HelpCommand implements Command {
     ${this.c("green", "audit")}            Security audit of JAR files
     ${this.c("green", "doctor")}           Diagnose and fix environment issues
     ${this.c("green", "profiles")}         List available Maven/Gradle profiles
+    ${this.c("green", "tomcat")}           Manage embedded Tomcat (install, list, status)
     ${this.c("green", "docs")}             Generate endpoint documentation
 
-  ${this.c("yellow", "OPTIONS")}
+  ${this.c("yellow", "GENERAL OPTIONS")}
     ${this.c("cyan", "-p, --path")} <path>     Tomcat installation path
     ${this.c("cyan", "-t, --tool")} <tool>     Build tool: maven | gradle
     ${this.c("cyan", "-n, --name")} <name>     Application name (WAR context)
@@ -43,32 +44,56 @@ export class HelpCommand implements Command {
     ${this.c("cyan", "-d, --debug")}          Enable JPDA debugger
     ${this.c("cyan", "--dp")} <port>          Debugger port (default: 5005)
     
-    ${this.c("cyan", "-c, --clean")}          Clean logs before start
+    ${this.c("cyan", "-c, --clean")}          Clean before build
     ${this.c("cyan", "-s, --no-build")}       Skip initial build
     ${this.c("cyan", "-q, --quiet")}          Minimal output
     ${this.c("cyan", "-V, --verbose")}        Detailed output
     ${this.c("cyan", "-h, --help")}           Show this help
     ${this.c("cyan", "-v, --version")}        Show version
 
+  ${this.c("yellow", "BUILD OPTIONS")}  ${this.c("dim", "(for deploy, dev, build)")}
+    ${this.c("cyan", "-W, --war")}             Generate .war file instead of exploded directory
+    ${this.c("cyan", "--cache")}              Use build cache (skip if no changes)
+
+  ${this.c("yellow", "TOMCAT OPTIONS")}  ${this.c("dim", "(for embedded Tomcat)")}
+    ${this.c("cyan", "--tomcat-version")} <v>   Tomcat version to install (default: 10.1.52)
+    ${this.c("cyan", "-y, --yes")}             Auto-install without confirmation
+
+  ${this.c("yellow", "DEPS OPTIONS")}  ${this.c("dim", "(for xavva deps)")}
+    ${this.c("cyan", "--update-safe")}         Update only non-breaking dependencies
+    ${this.c("cyan", "--fix")}                 Show fix suggestions for conflicts
+    ${this.c("cyan", "--strict")}              Fail on critical conflicts (for CI/CD)
+    ${this.c("cyan", "-o, --output")} <file>   Export report as JSON
+
   ${this.c("yellow", "EXAMPLES")}
     ${this.c("dim", "# Development with hot reload and dashboard")}
     xavva dev --tui --watch
 
-    ${this.c("dim", "# Quick deploy to specific Tomcat")}
+    ${this.c("dim", "# Deploy to specific Tomcat installation")}
     xavva deploy -p /opt/tomcat --port 8081
 
+    ${this.c("dim", "# Build and deploy as .war file")}
+    xavva deploy --war
+
     ${this.c("dim", "# Run a class with debugging")}
     xavva debug com.example.MyClass
 
-    ${this.c("dim", "# Analyze dependencies for conflicts")}
-    xavva deps --verbose
+    ${this.c("dim", "# Use embedded Tomcat (auto-install)")}
+    xavva dev --yes
+    xavva dev --tomcat-version 9.0.115
 
-    ${this.c("dim", "# Update safe dependencies (non-breaking only)")}
+    ${this.c("dim", "# Analyze and update dependencies")}
+    xavva deps --verbose
     xavva deps --update-safe
 
-    ${this.c("dim", "# Security audit with auto-fix suggestions")}
+    ${this.c("dim", "# Security audit with auto-fix")}
     xavva audit --fix
 
+    ${this.c("dim", "# Manage embedded Tomcat")}
+    xavva tomcat install
+    xavva tomcat status
+    xavva tomcat list
+
   ${this.c("yellow", "CONFIGURATION")}
     Settings are loaded from ${this.c("cyan", "xavva.json")} in the project root:
     

package/src/commands/ProfilesCommand.ts

@@ -20,7 +20,7 @@ export class ProfilesCommand implements Command {
         }
 
         Logger.log(`
-  ${Logger.C.cyan}Perfis detectados:${Logger.C.reset}`);
+  ${Logger.C.primary}Perfis detectados:${Logger.C.reset}`);
         profiles.forEach(p => {
             const active = config.project.profile === p ? ` ${Logger.C.green}(Ativo)${Logger.C.reset}` : "";
             Logger.log(`  ${Logger.C.bold}➜${Logger.C.reset} ${p}${active}`);

package/src/commands/RunCommand.ts

@@ -54,7 +54,7 @@ export class RunCommand implements Command {
 
         if (isDebug) {
             Logger.warn(`🚀 Aguardando debugger na porta 5005 para ${className}...`);
-            Logger.log(`${Logger.C.cyan}Dica:${Logger.C.reset} No VS Code ou IntelliJ, use 'Attach to Remote JVM' na porta 5005.`);
+            Logger.log(`${Logger.C.primary}Dica:${Logger.C.reset} No VS Code ou IntelliJ, use 'Attach to Remote JVM' na porta 5005.`);
             Logger.newline();
         } else {
             Logger.warn(`🚀 Executando ${className}...`);

package/src/commands/TomcatCommand.ts

@@ -0,0 +1,114 @@
+import type { Command } from "./Command";
+import type { AppConfig, CLIArguments } from "../types/config";
+import { EmbeddedTomcatService } from "../services/EmbeddedTomcatService";
+import { Logger } from "../utils/ui";
+import path from "path";
+
+export class TomcatCommand implements Command {
+    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
+        const action = args?.["tomcat-action"] || "status";
+        
+        switch (action) {
+            case "install":
+                await this.handleInstall(config, args);
+                break;
+            case "list":
+                this.handleList();
+                break;
+            case "uninstall":
+                await this.handleUninstall(config, args);
+                break;
+            case "status":
+                await this.handleStatus(config);
+                break;
+            default:
+                Logger.error(`Ação desconhecida: ${action}`);
+                Logger.info("Ações disponíveis", "install, list, uninstall, status");
+        }
+    }
+
+    private async handleInstall(config: AppConfig, args?: CLIArguments): Promise<void> {
+        const version = args?.["tomcat-version"] || config.tomcat.version || "10.1.52";
+        
+        // Detectar webapp path
+        const webappPath = config.project.buildTool === "maven"
+            ? path.join(process.cwd(), "src", "main", "webapp")
+            : path.join(process.cwd(), "src", "main", "webapp");
+
+        const service = new EmbeddedTomcatService({
+            version,
+            port: config.tomcat.port,
+            webappPath
+        });
+
+        if (service.checkInstallation()) {
+            Logger.info("Tomcat", `Versão ${version} já está instalada`);
+            const info = service.getInfo();
+            Logger.config("Local", info.home);
+            return;
+        }
+
+        const installed = await service.install();
+        if (installed) {
+            Logger.success(`Tomcat ${version} instalado com sucesso!`);
+        } else {
+            Logger.error("Falha na instalação");
+        }
+    }
+
+    private handleList(): void {
+        Logger.section("Versões Disponíveis");
+        const versions = EmbeddedTomcatService.getAvailableVersions();
+        
+        for (const version of versions) {
+            Logger.log(`  ${Logger.C.primary}•${Logger.C.reset} ${version}`);
+        }
+        
+        Logger.newline();
+        Logger.info("Versão padrão", "10.1.52");
+    }
+
+    private async handleUninstall(config: AppConfig, args?: CLIArguments): Promise<void> {
+        const version = args?.["tomcat-version"] || config.tomcat.version || "10.1.52";
+        
+        const service = new EmbeddedTomcatService({
+            version,
+            port: config.tomcat.port,
+            webappPath: "."
+        });
+
+        if (!service.checkInstallation()) {
+            Logger.warn(`Tomcat ${version} não está instalado`);
+            return;
+        }
+
+        Logger.step(`Removendo Tomcat ${version}...`);
+        await service.uninstall();
+        Logger.success("Removido com sucesso!");
+    }
+
+    private async handleStatus(config: AppConfig): Promise<void> {
+        Logger.section("Status do Tomcat");
+        
+        if (config.tomcat.embedded) {
+            Logger.config("Modo", "Embutido");
+            Logger.config("Versão", config.tomcat.version || "10.1.52");
+            Logger.config("Porta", String(config.tomcat.port));
+            Logger.config("Home", config.tomcat.path);
+        } else {
+            Logger.config("Modo", "Externo");
+            Logger.config("CATALINA_HOME", config.tomcat.path);
+            Logger.config("Porta", String(config.tomcat.port));
+        }
+        
+        // Verificar se está rodando
+        const netstat = Bun.spawnSync(["cmd", "/c", `netstat -ano | findstr :${config.tomcat.port}`]);
+        const output = await new Response(netstat.stdout).text();
+        
+        if (output.trim()) {
+            Logger.config("Status", `${Logger.C.success}Rodando${Logger.C.reset}`);
+        } else {
+            Logger.config("Status", `${Logger.C.warning}Parado${Logger.C.reset}`);
+        }
+    }
+}

package/src/index.ts

@@ -12,6 +12,7 @@ import { DocsCommand } from "./commands/DocsCommand";
 import { AuditCommand } from "./commands/AuditCommand";
 import { ProfilesCommand } from "./commands/ProfilesCommand";
 import { DepsCommand } from "./commands/DepsCommand";
+import { TomcatCommand } from "./commands/TomcatCommand";
 
 import { ProjectService } from "./services/ProjectService";
 import { TomcatService } from "./services/TomcatService";
@@ -36,7 +37,7 @@ async function main() {
 		await processManager.shutdown(0);
 	}
 
-	const commandNames = ["deploy", "build", "start", "dev", "doctor", "run", "debug", "logs", "docs", "audit", "profiles", "deps"];
+	const commandNames = ["deploy", "build", "start", "dev", "doctor", "run", "debug", "logs", "docs", "audit", "profiles", "deps", "tomcat"];
 	const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
 
 	if (!values.help && !values.tui) {
@@ -44,6 +45,9 @@ async function main() {
 		if (config.project.encoding) {
 			Logger.config("Encoding", config.project.encoding);
 		}
+		if (config.tomcat.embedded) {
+			Logger.config("Tomcat", `Embutido ${config.tomcat.version}`);
+		}
 	}
 
 	if (values.help) {
@@ -80,6 +84,7 @@ async function main() {
 	registry.register("audit", new AuditCommand(auditService));
 	registry.register("profiles", new ProfilesCommand(projectService));
 	registry.register("deps", new DepsCommand());
+	registry.register("tomcat", new TomcatCommand());
 	registry.register("deploy", deployCmd);
 	registry.register("dev", deployCmd);
 

package/src/services/BuildService.ts

@@ -30,7 +30,10 @@ export class BuildService {
 			this.cache.clearCache();
 		}
 
-		if (!incremental && !this.projectConfig.skipBuild) {
+		// Cache só é usado se --cache for passado ou em modo incremental
+		const useCache = this.projectConfig.cache || incremental;
+		
+		if (useCache && !incremental && !this.projectConfig.skipBuild) {
 			if (!this.projectConfig.clean && !this.cache.shouldRebuild(this.projectConfig.buildTool, this.projectService)) {
 				Logger.success("Build cache hit! Skipping full build.");
 				return;
@@ -43,8 +46,8 @@ export class BuildService {
 		if (this.projectConfig.buildTool === 'maven') {
 			command.push(process.platform === "win32" ? "mvn.cmd" : "mvn");
 
-			// Smart Offline: Se o pom.xml não mudou e é incremental ou rebuild forçado (mas cache existe), usa -o
-			if (!this.cache.shouldRebuild('maven', this.projectService)) {
+			// Smart Offline: só usa -o se cache estiver habilitado e pom não mudou
+			if (useCache && !this.cache.shouldRebuild('maven', this.projectService)) {
 				command.push("-o");
 			}
 
@@ -52,7 +55,12 @@ export class BuildService {
 				command.push("compile");
 			} else {
 				if (this.projectConfig.clean) command.push("clean");
-				command.push("compile", "war:exploded");
+				// Use 'package' para gerar .war ou 'war:exploded' para pasta
+				if (this.projectConfig.war) {
+					command.push("package");
+				} else {
+					command.push("compile", "war:exploded");
+				}
 				command.push("-T", "1C");
 			}
 			command.push("-Dmaven.test.skip=true", "-Dmaven.javadoc.skip=true");

package/src/services/DependencyAnalyzerService.ts

@@ -417,6 +417,14 @@ export class DependencyAnalyzerService {
 
 	private async checkSingleUpdate(dep: Dependency): Promise<DependencyUpdate | null> {
 		try {
+			// Primeiro verifica se a versão atual existe no Maven Central
+			// Se não existir, é uma dependência local - não sugerir atualização
+			const currentExists = await this.checkVersionExists(dep.groupId, dep.artifactId, dep.version);
+			if (!currentExists) {
+				Logger.debug(`Dependência local detectada (não no Maven Central): ${dep.groupId}:${dep.artifactId}:${dep.version}`);
+				return null;
+			}
+			
 			const latest = await this.fetchLatestVersion(dep.groupId, dep.artifactId);
 			if (latest && this.isNewer(latest, dep.version)) {
 				return {
@@ -433,6 +441,18 @@ export class DependencyAnalyzerService {
 		return null;
 	}
 
+	private async checkVersionExists(groupId: string, artifactId: string, version: string): Promise<boolean> {
+		try {
+			const url = `https://search.maven.org/solrsearch/select?q=g:"${groupId}"+AND+a:"${artifactId}"+AND+v:"${version}"&rows=1&wt=json`;
+			const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+			const data = await response.json();
+			return data.response?.numFound > 0;
+		} catch (e) {
+			// Se não conseguir verificar, assume que existe para não bloquear
+			return true;
+		}
+	}
+
 	private async fetchLatestVersion(groupId: string, artifactId: string): Promise<string | null> {
 		// Usar Maven Central API
 		try {
@@ -505,13 +525,17 @@ export class DependencyAnalyzerService {
 			const currentVersion = update.currentVersion.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 			
 			// Regex para encontrar <version> dentro do bloco da dependência
+			// Captura: grupo 1 = tudo antes da versão incluindo <version>
+			//          grupo 2 = a versão atual
+			//          grupo 3 = </version> e resto
 			const depPattern = new RegExp(
-				`(<dependency>\\s*<groupId>${groupId}</groupId>\\s*<artifactId>${artifactId}</artifactId>(?:\\s*<version>)${currentVersion}(</version>))`,
+				`(<dependency>\\s*<groupId>${groupId}</groupId>\\s*<artifactId>${artifactId}</artifactId>\\s*<version>)(${currentVersion})(</version>)`,
 				'g'
 			);
 			
 			if (depPattern.test(content)) {
-				content = content.replace(depPattern, `$1${update.latestVersion}$2`);
+				// Substitui apenas o grupo 2 (a versão), mantendo as tags
+				content = content.replace(depPattern, `$1${update.latestVersion}$3`);
 				result.updated++;
 				modified = true;
 			} else {

package/src/services/EmbeddedTomcatService.ts

@@ -0,0 +1,391 @@
+import { Logger } from "../utils/ui";
+import { existsSync, mkdirSync, createWriteStream, writeFileSync, promises as fs } from "fs";
+import path from "path";
+import os from "os";
+import { spawn } from "child_process";
+
+export interface EmbeddedTomcatOptions {
+    version?: string;
+    port?: number;
+    webappPath: string;
+    contextPath?: string;
+}
+
+interface DownloadProgress {
+    downloaded: number;
+    total: number;
+    percent: number;
+}
+
+export class EmbeddedTomcatService {
+    private readonly baseDir: string;
+    private readonly version: string;
+    private port: number;
+    private webappPath: string;
+    private contextPath: string;
+    private tomcatHome: string;
+    private downloadUrl: string;
+    private isInstalled: boolean = false;
+
+    // Versões estáveis do Tomcat (atualizadas: 2026-03-04)
+    private static readonly VERSIONS: Record<string, { url: string; sha512: string }> = {
+        "10.1.52": {
+            url: "https://dlcdn.apache.org/tomcat/tomcat-10/v10.1.52/bin/apache-tomcat-10.1.52-windows-x64.zip",
+            sha512: ""
+        },
+        "9.0.115": {
+            url: "https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.115/bin/apache-tomcat-9.0.115-windows-x64.zip",
+            sha512: ""
+        },
+        "11.0.18": {
+            url: "https://dlcdn.apache.org/tomcat/tomcat-11/v11.0.18/bin/apache-tomcat-11.0.18-windows-x64.zip",
+            sha512: ""
+        }
+    };
+
+    constructor(options: EmbeddedTomcatOptions) {
+        this.version = options.version || "10.1.52";
+        this.port = options.port || 8080;
+        this.webappPath = path.resolve(options.webappPath);
+        this.contextPath = options.contextPath || "/";
+        this.baseDir = path.join(os.homedir(), ".xavva", "tomcat");
+        this.tomcatHome = path.join(this.baseDir, this.version);
+        
+        // Se a versão não está na lista, usa URL padrão
+        const versionInfo = EmbeddedTomcatService.VERSIONS[this.version];
+        if (versionInfo) {
+            this.downloadUrl = versionInfo.url;
+        } else {
+            // Tenta inferir URL baseado no padrão Apache
+            const majorVersion = this.version.split(".")[0];
+            this.downloadUrl = `https://archive.apache.org/dist/tomcat/tomcat-${majorVersion}/v${this.version}/bin/apache-tomcat-${this.version}-windows-x64.zip`;
+        }
+    }
+
+    /**
+     * Verifica se o Tomcat já está instalado
+     */
+    checkInstallation(): boolean {
+        const catalinaBat = path.join(this.tomcatHome, "bin", "catalina.bat");
+        this.isInstalled = existsSync(catalinaBat);
+        return this.isInstalled;
+    }
+
+    /**
+     * Retorna o caminho do Tomcat (instalado ou para instalar)
+     */
+    getTomcatHome(): string {
+        return this.tomcatHome;
+    }
+
+    /**
+     * Baixa e instala o Tomcat
+     */
+    async install(): Promise<boolean> {
+        if (this.checkInstallation()) {
+            Logger.info("Tomcat", `Versão ${this.version} já instalada`);
+            return true;
+        }
+
+        Logger.section("Instalando Tomcat Embutido");
+        Logger.info("Versão", this.version);
+        Logger.info("Destino", this.tomcatHome);
+
+        // Cria diretório base
+        if (!existsSync(this.baseDir)) {
+            mkdirSync(this.baseDir, { recursive: true });
+        }
+
+        const zipPath = path.join(this.baseDir, `apache-tomcat-${this.version}.zip`);
+
+        try {
+            // Download
+            await this.downloadFile(this.downloadUrl, zipPath);
+
+            // Extração
+            await this.extractZip(zipPath, this.baseDir);
+
+            // Renomeia diretório extraído para versão padronizada
+            const extractedDir = path.join(this.baseDir, `apache-tomcat-${this.version}`);
+            if (existsSync(extractedDir) && extractedDir !== this.tomcatHome) {
+                await fs.rename(extractedDir, this.tomcatHome);
+            }
+
+            // Limpa arquivo zip
+            await fs.unlink(zipPath).catch(() => {});
+
+            // Configura server.xml
+            await this.configureServerXml();
+
+            // Configura context.xml para hot-reload
+            await this.configureContextXml();
+
+            this.isInstalled = true;
+            Logger.success(`Tomcat ${this.version} instalado com sucesso!`);
+            return true;
+
+        } catch (error) {
+            Logger.error(`Falha ao instalar Tomcat: ${error}`);
+            // Limpa arquivos parciais
+            if (existsSync(this.tomcatHome)) {
+                await fs.rm(this.tomcatHome, { recursive: true, force: true });
+            }
+            return false;
+        }
+    }
+
+    /**
+     * Configura server.xml com porta personalizada
+     */
+    private async configureServerXml(): Promise<void> {
+        const serverXmlPath = path.join(this.tomcatHome, "conf", "server.xml");
+        
+        if (!existsSync(serverXmlPath)) {
+            throw new Error("server.xml não encontrado após extração");
+        }
+
+        let content = await fs.readFile(serverXmlPath, "utf-8");
+
+        // Atualiza porta HTTP
+        content = content.replace(
+            /<Connector port="8080"/,
+            `<Connector port="${this.port}"`
+        );
+
+        // Atualiza porta de shutdown
+        const shutdownPort = this.port + 1000;
+        content = content.replace(
+            /<Server port="8005"/,
+            `<Server port="${shutdownPort}"`
+        );
+
+        // Atualiza porta AJP (se existir)
+        content = content.replace(
+            /<Connector port="8009"/,
+            `<Connector port="${this.port + 1001}"`
+        );
+
+        // Desabilita manager e host-manager em embedded (opcional)
+        // Remove context do manager para segurança
+        content = content.replace(
+            /<Context docBase="manager"[^>]*\/>/g,
+            "<!-- <Context docBase=\"manager\" ... /> -->"
+        );
+
+        await fs.writeFile(serverXmlPath, content, "utf-8");
+        Logger.debug(`server.xml configurado na porta ${this.port}`);
+    }
+
+    /**
+     * Configura context.xml para hot-reload
+     */
+    private async configureContextXml(): Promise<void> {
+        const contextXmlPath = path.join(this.tomcatHome, "conf", "context.xml");
+        
+        if (!existsSync(contextXmlPath)) return;
+
+        let content = await fs.readFile(contextXmlPath, "utf-8");
+
+        // Adiciona atributos para hot-reload se não existirem
+        if (!content.includes("reloadable")) {
+            content = content.replace(
+                /<Context>/,
+                '<Context reloadable="true" autoDeploy="true" deployOnStartup="true">'
+            );
+        }
+
+        await fs.writeFile(contextXmlPath, content, "utf-8");
+    }
+
+    /**
+     * Cria contexto para a aplicação
+     */
+    async createAppContext(): Promise<void> {
+        const webappsDir = path.join(this.tomcatHome, "webapps");
+        
+        // Limpa webapps padrão
+        const defaultApps = ["docs", "examples", "host-manager", "manager", "ROOT"];
+        for (const app of defaultApps) {
+            const appPath = path.join(webappsDir, app);
+            if (existsSync(appPath)) {
+                await fs.rm(appPath, { recursive: true, force: true });
+            }
+        }
+
+        // Cria diretório para a aplicação
+        const appName = this.contextPath === "/" ? "ROOT" : this.contextPath.replace(/^\//, "");
+        const appDir = path.join(webappsDir, appName);
+
+        if (existsSync(appDir)) {
+            await fs.rm(appDir, { recursive: true, force: true });
+        }
+
+        // Se webappPath é um diretório, cria link/simula deploy
+        if (existsSync(this.webappPath)) {
+            // Em Windows, vamos copiar inicialmente (symlink requer privilégios)
+            // Ou criar um context XML apontando para o diretório
+            await this.createContextXml(appName);
+        }
+    }
+
+    /**
+     * Cria arquivo context XML para apontar para diretório externo
+     */
+    private async createContextXml(appName: string): Promise<void> {
+        const confDir = path.join(this.tomcatHome, "conf", "Catalina", "localhost");
+        
+        if (!existsSync(confDir)) {
+            mkdirSync(confDir, { recursive: true });
+        }
+
+        const contextFile = path.join(confDir, `${appName}.xml`);
+        const content = `<?xml version="1.0" encoding="UTF-8"?>
+<Context 
+    docBase="${this.webappPath.replace(/\\/g, "/")}"
+    reloadable="true"
+    crossContext="true"
+    antiResourceLocking="false"
+    antiJARLocking="false">
+</Context>`;
+
+        writeFileSync(contextFile, content);
+        Logger.debug(`Context criado: ${contextFile}`);
+    }
+
+    /**
+     * Verifica se porta está disponível
+     */
+    async isPortAvailable(): Promise<boolean> {
+        return new Promise((resolve) => {
+            const netstat = spawn("cmd", ["/c", `netstat -ano | findstr :${this.port}`]);
+            let output = "";
+
+            netstat.stdout?.on("data", (data) => {
+                output += data.toString();
+            });
+
+            netstat.on("close", () => {
+                resolve(output.trim().length === 0);
+            });
+
+            netstat.on("error", () => {
+                resolve(true); // Assume disponível se não conseguir verificar
+            });
+        });
+    }
+
+    /**
+     * Encontra próxima porta disponível
+     */
+    async findAvailablePort(startPort: number = 8080): Promise<number> {
+        let port = startPort;
+        while (!(await this.isPortAvailable())) {
+            port++;
+            if (port > 65535) {
+                throw new Error("Nenhuma porta disponível encontrada");
+            }
+        }
+        this.port = port;
+        return port;
+    }
+
+    /**
+     * Retorna variáveis de ambiente para o Tomcat
+     */
+    getEnvironment(): Record<string, string> {
+        return {
+            CATALINA_HOME: this.tomcatHome,
+            CATALINA_BASE: this.tomcatHome,
+            CATALINA_OPTS: process.env.CATALINA_OPTS || ""
+        };
+    }
+
+    /**
+     * Lista versões disponíveis
+     */
+    static getAvailableVersions(): string[] {
+        return Object.keys(EmbeddedTomcatService.VERSIONS);
+    }
+
+    /**
+     * Download com progresso
+     */
+    private async downloadFile(url: string, destPath: string): Promise<void> {
+        const spinner = Logger.spinner(`Baixando Tomcat ${this.version}...`);
+
+        try {
+            const response = await fetch(url);
+            
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+
+            const totalSize = parseInt(response.headers.get("content-length") || "0");
+            const buffer = await response.arrayBuffer();
+            
+            writeFileSync(destPath, Buffer.from(buffer));
+            
+            spinner(true);
+            
+            const sizeMB = (buffer.byteLength / 1024 / 1024).toFixed(1);
+            Logger.info("Download", `${sizeMB} MB baixados`);
+
+        } catch (error) {
+            spinner(false);
+            throw error;
+        }
+    }
+
+    /**
+     * Extrai arquivo ZIP usando PowerShell
+     */
+    private async extractZip(zipPath: string, destDir: string): Promise<void> {
+        const spinner = Logger.spinner("Extraindo arquivos...");
+
+        return new Promise((resolve, reject) => {
+            const ps = spawn("powershell", [
+                "-command",
+                `Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force`
+            ]);
+
+            ps.on("close", (code) => {
+                if (code === 0) {
+                    spinner(true);
+                    resolve();
+                } else {
+                    spinner(false);
+                    reject(new Error(`Falha ao extrair (código ${code})`));
+                }
+            });
+
+            ps.on("error", (err) => {
+                spinner(false);
+                reject(err);
+            });
+        });
+    }
+
+    /**
+     * Remove instalação
+     */
+    async uninstall(): Promise<void> {
+        if (existsSync(this.tomcatHome)) {
+            await fs.rm(this.tomcatHome, { recursive: true, force: true });
+            Logger.info("Tomcat", `Versão ${this.version} removida`);
+        }
+    }
+
+    /**
+     * Retorna informações da instalação
+     */
+    getInfo(): Record<string, string> {
+        return {
+            version: this.version,
+            home: this.tomcatHome,
+            port: String(this.port),
+            installed: this.isInstalled ? "sim" : "não",
+            webapp: this.webappPath,
+            context: this.contextPath
+        };
+    }
+}

package/src/services/LogAnalyzer.ts

@@ -98,7 +98,7 @@ export class LogAnalyzer {
             return `${Logger.C.magenta}👀 ${Logger.C.bold}Hotswap:${Logger.C.reset} ${msg.replace(/Class '.*?'/, (m) => Logger.C.bold + m + Logger.C.reset)}`;
         }
 
-        let color = Logger.C.cyan;
+        let color = Logger.C.primary;
         let symbol = "●";
         if (level === "WARN") { color = Logger.C.yellow; symbol = "▲"; }
         else if (level === "ERROR") { color = Logger.C.red; symbol = "✖"; }

package/src/services/ProjectService.ts

@@ -28,7 +28,12 @@ export class ProjectService {
         const artifacts = this.searchArtifacts(buildDir).sort((a, b) => b.time - a.time);
 
         if (artifacts.length === 0) {
-            throw new Error(`Nenhum artefato (.war ou pasta exploded) encontrado em ${buildDir}!`);
+            // Debug: listar o que existe no diretório target
+            let debugInfo = `\nDiretório ${buildDir} existe: ${existsSync(buildDir)}`;
+            if (existsSync(buildDir)) {
+                debugInfo += `\nConteúdo: ${readdirSync(buildDir).join(', ')}`;
+            }
+            throw new Error(`Nenhum artefato (.war ou pasta exploded) encontrado em ${buildDir}!${debugInfo}`);
         }
 
         const artifact = artifacts[0];

package/src/types/config.ts

@@ -3,6 +3,8 @@ export interface TomcatConfig {
     port: number;
     webapps: string;
     grep?: string;
+    embedded?: boolean;
+    version?: string;
 }
 
 export interface ProjectConfig {
@@ -20,6 +22,8 @@ export interface ProjectConfig {
     grep?: string;
     tui: boolean;
     encoding?: string;
+    war?: boolean;
+    cache?: boolean;
 }
 
 export interface AppConfig {
@@ -50,6 +54,13 @@ export interface CLIArguments {
     tui?: boolean;
     output?: string;
     strict?: boolean;
+    "tomcat-version"?: string;
+    "tomcat-action"?: string;
+    "update-safe"?: boolean;
+    "updateSafe"?: boolean;
+    yes?: boolean;
+    war?: boolean;
+    cache?: boolean;
 }
 
 export interface CommandContext {

package/src/utils/config.ts

@@ -3,6 +3,8 @@ import path from "path";
 import fs from "fs";
 import { DEFAULT_TOMCAT_PORT, DEFAULT_DEBUG_PORT } from "./constants";
 import type { AppConfig, CLIArguments, CommandContext } from "../types/config";
+import { EmbeddedTomcatService } from "../services/EmbeddedTomcatService";
+import { Logger } from "./ui";
 
 export class ConfigManager {
     static async load(): Promise<CommandContext> {
@@ -32,6 +34,10 @@ export class ConfigManager {
                 tui: { type: "boolean" },
                 output: { type: "string", short: "o" },
                 strict: { type: "boolean" },
+                "tomcat-version": { type: "string" },
+                yes: { type: "boolean", short: "y" },
+                war: { type: "boolean", short: "W" },
+                cache: { type: "boolean" },
             },
             strict: false,
             allowPositionals: true,
@@ -52,8 +58,9 @@ export class ConfigManager {
 
         const isDev = positionals.includes("dev");
         const isRun = positionals.includes("run") || positionals.includes("debug");
+        const isStart = positionals.includes("start") || positionals.includes("deploy") || isDev;
         
-        const envTomcatPath = process.env.TOMCAT_HOME || process.env.CATALINA_HOME || "C:\\apache-tomcat";
+        const envTomcatPath = process.env.TOMCAT_HOME || process.env.CATALINA_HOME;
         const detectedTool = this.detectBuildTool();
 
         let runClass = "";
@@ -64,12 +71,77 @@ export class ConfigManager {
             runClass = positionals[idx + 1] || "";
         }
 
+        // Detectar webapp path baseado no build tool
+        const webappPath = detectedTool === "maven" 
+            ? path.join(process.cwd(), "src", "main", "webapp")
+            : path.join(process.cwd(), "src", "main", "webapp");
+
+        // Verificar se usar Tomcat embutido
+        let tomcatPath = String(cliValues.path || xavvaJson.path || envTomcatPath || "");
+        let useEmbedded = false;
+        let embeddedVersion = String(cliValues["tomcat-version"] || xavvaJson.version || "10.1.52");
+
+        // Se não há Tomcat configurado ou não existe no path, usar embutido
+        if (!tomcatPath || (!fs.existsSync(path.join(tomcatPath, "bin", "catalina.bat")) && isStart)) {
+            useEmbedded = true;
+            const embeddedService = new EmbeddedTomcatService({
+                version: embeddedVersion,
+                port: parseInt(String(cliValues.port || xavvaJson.port || String(DEFAULT_TOMCAT_PORT))),
+                webappPath: webappPath
+            });
+            
+            // Instala se necessário
+            if (!embeddedService.checkInstallation()) {
+                Logger.newline();
+                Logger.warn("Tomcat não encontrado!");
+                Logger.info("Versão solicitada", embeddedVersion);
+                Logger.newline();
+                Logger.log(`${Logger.C.primary}?${Logger.C.reset} Deseja instalar o Tomcat ${embeddedVersion} automaticamente?`);
+                Logger.log(`${Logger.C.dim}  O download é de ~16MB e será salvo em:~/.xavva/tomcat/${embeddedVersion}${Logger.C.reset}`);
+                Logger.newline();
+                
+                // Garante que não há output pendente antes da pergunta
+                await new Promise(resolve => setTimeout(resolve, 50));
+                process.stdout.write('\r\x1b[K'); // Limpa linha atual
+                
+                const autoYes = !!cliValues.yes;
+                const shouldInstall = autoYes || await this.askYesNo("Instalar");
+                
+                if (!shouldInstall) {
+                    Logger.newline();
+                    Logger.info("Opções disponíveis", "");
+                    Logger.log(`  ${Logger.C.primary}1.${Logger.C.reset} Defina TOMCAT_HOME ou CATALINA_HOME`);
+                    Logger.log(`  ${Logger.C.primary}2.${Logger.C.reset} Use --path para especificar o Tomcat`);
+                    Logger.log(`  ${Logger.C.primary}3.${Logger.C.reset} Use --tomcat-version para outra versão`);
+                    Logger.newline();
+                    process.exit(0);
+                }
+                
+                Logger.newline();
+                const installed = await embeddedService.install();
+                if (!installed) {
+                    Logger.error("Falha ao instalar Tomcat embutido.");
+                    Logger.info("Dica", "Instale o Tomcat manualmente ou defina TOMCAT_HOME");
+                    process.exit(1);
+                }
+            } else {
+                Logger.info("Tomcat", `Usando versão embutida ${embeddedVersion}`);
+            }
+            
+            // Configura contexto da aplicação
+            await embeddedService.createAppContext();
+            
+            tomcatPath = embeddedService.getTomcatHome();
+        }
+
         const config: AppConfig = {
             tomcat: {
-                path: String(cliValues.path || xavvaJson.path || envTomcatPath),
+                path: tomcatPath,
                 port: parseInt(String(cliValues.port || xavvaJson.port || String(DEFAULT_TOMCAT_PORT))),
                 webapps: "webapps",
                 grep: cliValues.grep || xavvaJson.grep ? String(cliValues.grep || xavvaJson.grep) : "",
+                embedded: useEmbedded,
+                version: embeddedVersion,
             },
             project: {
                 appName: cliValues.name || xavvaJson.name ? String(cliValues.name || xavvaJson.name) : "",
@@ -86,6 +158,8 @@ export class ConfigManager {
                 grep: runClass || (cliValues.grep || xavvaJson.grep ? String(cliValues.grep || xavvaJson.grep) : ""),
                 tui: !!(cliValues.tui ?? xavvaJson.tui),
                 encoding: cliValues.encoding || xavvaJson.encoding || "",
+                war: !!(cliValues.war ?? xavvaJson.war),
+                cache: !!(cliValues.cache ?? xavvaJson.cache),
             }
         };
 
@@ -106,6 +180,50 @@ export class ConfigManager {
         return "maven";
     }
 
+    private static async askYesNo(question: string): Promise<boolean> {
+        // Pequeno delay para garantir que o output anterior foi processado
+        await new Promise(resolve => setTimeout(resolve, 100));
+        
+        // Limpa qualquer coisa pendente no stdout
+        process.stdout.write('\x1b[0m');
+        
+        return new Promise((resolve) => {
+            const chunks: Buffer[] = [];
+            
+            const cleanup = () => {
+                process.stdin.removeListener('data', onData);
+                process.stdin.removeListener('end', onEnd);
+                process.stdin.pause();
+            };
+            
+            const onData = (data: Buffer) => {
+                chunks.push(data);
+                const str = Buffer.concat(chunks).toString();
+                
+                // Procura por enter no input
+                if (str.includes('\n') || str.includes('\r')) {
+                    cleanup();
+                    const answer = str.replace(/\r?\n/g, '').trim().toLowerCase();
+                    process.stdout.write('\n');
+                    resolve(answer === '' || answer === 'y' || answer === 'yes');
+                }
+            };
+            
+            const onEnd = () => {
+                cleanup();
+                const answer = Buffer.concat(chunks).toString().trim().toLowerCase();
+                resolve(answer === '' || answer === 'y' || answer === 'yes');
+            };
+            
+            // Mostra a pergunta
+            process.stdout.write(`${question} [Y/n]: `);
+            
+            process.stdin.resume();
+            process.stdin.on('data', onData);
+            process.stdin.on('end', onEnd);
+        });
+    }
+
     private static ensureGitIgnore() {
         const gitignorePath = path.join(process.cwd(), ".gitignore");