@archznn/xavva 2.3.0 → 2.4.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.3.0-blue.svg)](https://github.com/leorsousa05/Xavva)
+[![Version](https://img.shields.io/badge/version-2.4.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.
@@ -102,16 +102,25 @@ Xavva can automatically download and manage a Tomcat installation for you:
 # First time usage - auto-install Tomcat
 xavva dev --yes
 
-# Or install manually
-xavva tomcat install
+# List available versions to download
+xavva tomcat list
+
+# List already installed versions
+xavva tomcat installed
+
+# Install a specific version
+xavva tomcat install 9.0.115
+
+# Switch to a version for this project
+xavva tomcat use 9.0.115
 
 # Check Tomcat status
 xavva tomcat status
 
-# List available versions
-xavva tomcat list
+# Remove a version
+xavva tomcat uninstall 9.0.115
 
-# Use specific version
+# Or use with flags
 xavva dev --tomcat-version 9.0.115
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.3.0",
+	"version": "2.4.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/Command.ts

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

package/src/commands/CommandRegistry.ts

@@ -19,18 +19,18 @@ export class CommandRegistry {
         return this.commands.get(name);
     }
 
-    async execute(name: string, config: AppConfig, args: CLIArguments): Promise<void> {
+    async execute(name: string, config: AppConfig, args: CLIArguments, positionals?: string[]): Promise<void> {
         const command = this.commands.get(name);
         const processManager = ProcessManager.getInstance();
         
         if (!command) {
             Logger.error(`Comando desconhecido: ${name}`);
-            await new HelpCommand().execute(config);
+            await new HelpCommand().execute(config, args, positionals);
             await processManager.shutdown(2);
         }
 
         try {
-            await command.execute(config, args);
+            await command.execute(config, args, positionals);
         } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             Logger.error(`Erro ao executar comando '${name}': ${message}`);

package/src/commands/HelpCommand.ts

@@ -28,7 +28,7 @@ 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", "tomcat")}           Manage embedded Tomcat (install, list, installed, use, status)
     ${this.c("green", "docs")}             Generate endpoint documentation
 
   ${this.c("yellow", "GENERAL OPTIONS")}
@@ -90,9 +90,12 @@ export class HelpCommand implements Command {
     xavva audit --fix
 
     ${this.c("dim", "# Manage embedded Tomcat")}
-    xavva tomcat install
+    xavva tomcat list              # List available versions
+    xavva tomcat installed         # List installed versions
+    xavva tomcat install 9.0.115   # Install specific version
+    xavva tomcat use 9.0.115       # Switch to version for this project
     xavva tomcat status
-    xavva tomcat list
+    xavva tomcat uninstall 9.0.115
 
   ${this.c("yellow", "CONFIGURATION")}
     Settings are loaded from ${this.c("cyan", "xavva.json")} in the project root:

package/src/commands/TomcatCommand.ts

@@ -3,32 +3,47 @@ import type { AppConfig, CLIArguments } from "../types/config";
 import { EmbeddedTomcatService } from "../services/EmbeddedTomcatService";
 import { Logger } from "../utils/ui";
 import path from "path";
+import fs from "fs";
 
 export class TomcatCommand implements Command {
-    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
-        const action = args?.["tomcat-action"] || "status";
+    async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
+        // A ação vem como positional após "tomcat" (ex: xavva tomcat list)
+        const tomcatIndex = positionals?.indexOf("tomcat") ?? -1;
+        const action = positionals && tomcatIndex >= 0 && positionals[tomcatIndex + 1] 
+            ? positionals[tomcatIndex + 1] 
+            : "status";
+        
+        // Argumentos extras após a ação (ex: xavva tomcat install 9.0.115)
+        const extraArgs = positionals && tomcatIndex >= 0 ? positionals.slice(tomcatIndex + 2) : [];
         
         switch (action) {
             case "install":
-                await this.handleInstall(config, args);
+                await this.handleInstall(config, args, extraArgs);
                 break;
             case "list":
                 this.handleList();
                 break;
+            case "installed":
+                this.handleInstalled();
+                break;
+            case "use":
+                await this.handleUse(config, args, extraArgs);
+                break;
             case "uninstall":
-                await this.handleUninstall(config, args);
+                await this.handleUninstall(config, args, extraArgs);
                 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");
+                Logger.info("Ações disponíveis", "install, list, installed, use, uninstall, status");
         }
     }
 
-    private async handleInstall(config: AppConfig, args?: CLIArguments): Promise<void> {
-        const version = args?.["tomcat-version"] || config.tomcat.version || "10.1.52";
+    private async handleInstall(config: AppConfig, args?: CLIArguments, extraArgs: string[] = []): Promise<void> {
+        // Versão pode vir de: flag --tomcat-version, argumento posicional, config, ou padrão
+        const version = args?.["tomcat-version"] || extraArgs[0] || config.tomcat.version || "10.1.52";
         
         // Detectar webapp path
         const webappPath = config.project.buildTool === "maven"
@@ -57,7 +72,7 @@ export class TomcatCommand implements Command {
     }
 
     private handleList(): void {
-        Logger.section("Versões Disponíveis");
+        Logger.section("Versões Disponíveis para Download");
         const versions = EmbeddedTomcatService.getAvailableVersions();
         
         for (const version of versions) {
@@ -66,10 +81,90 @@ export class TomcatCommand implements Command {
         
         Logger.newline();
         Logger.info("Versão padrão", "10.1.52");
+        Logger.newline();
+        Logger.info("Dica", "Use 'xavva tomcat installed' para ver versões já instaladas");
+    }
+
+    private handleInstalled(): void {
+        const installed = EmbeddedTomcatService.listInstalledVersions();
+        
+        Logger.section("Versões Instaladas");
+        
+        if (installed.length === 0) {
+            Logger.warn("Nenhuma versão instalada");
+            Logger.info("Dica", "Use 'xavva tomcat install <version>' para instalar");
+            return;
+        }
+        
+        for (const version of installed) {
+            Logger.log(`  ${Logger.C.success}✓${Logger.C.reset} ${version}`);
+        }
+        
+        Logger.newline();
+        Logger.info("Para usar uma versão", "xavva tomcat use <version>");
+    }
+
+    private async handleUse(config: AppConfig, args?: CLIArguments, extraArgs: string[] = []): Promise<void> {
+        const version = extraArgs[0] || args?.["tomcat-version"];
+        
+        if (!version) {
+            Logger.error("Versão não especificada");
+            Logger.info("Uso", "xavva tomcat use <version>");
+            Logger.info("Exemplo", "xavva tomcat use 9.0.115");
+            Logger.newline();
+            Logger.info("Versões instaladas", "");
+            this.handleInstalled();
+            return;
+        }
+        
+        // Verifica se a versão está instalada
+        const service = new EmbeddedTomcatService({
+            version,
+            port: config.tomcat.port,
+            webappPath: "."
+        });
+        
+        if (!service.checkInstallation()) {
+            Logger.warn(`Tomcat ${version} não está instalado`);
+            Logger.newline();
+            Logger.info("Opções", "");
+            Logger.log(`  ${Logger.C.primary}1.${Logger.C.reset} Instalar agora: xavva tomcat install ${version}`);
+            Logger.log(`  ${Logger.C.primary}2.${Logger.C.reset} Ver instaladas: xavva tomcat installed`);
+            return;
+        }
+        
+        // Salva a versão no xavva.json do projeto
+        await this.saveTomcatVersion(version);
+        
+        Logger.success(`Tomcat ${version} configurado para este projeto!`);
+        Logger.newline();
+        Logger.info("Próximos comandos", "");
+        Logger.log(`  ${Logger.C.primary}•${Logger.C.reset} xavva dev    # Iniciar desenvolvimento`);
+        Logger.log(`  ${Logger.C.primary}•${Logger.C.reset} xavva deploy # Fazer deploy`);
+    }
+
+    private async saveTomcatVersion(version: string): Promise<void> {
+        const xavvaJsonPath = path.join(process.cwd(), "xavva.json");
+        let config: any = {};
+        
+        if (fs.existsSync(xavvaJsonPath)) {
+            try {
+                config = JSON.parse(fs.readFileSync(xavvaJsonPath, "utf-8"));
+            } catch (e) {
+                // Arquivo existe mas é inválido, começa do zero
+            }
+        }
+        
+        if (!config.tomcat) config.tomcat = {};
+        config.tomcat.version = version;
+        config.tomcat.embedded = true;
+        
+        fs.writeFileSync(xavvaJsonPath, JSON.stringify(config, null, 2));
     }
 
-    private async handleUninstall(config: AppConfig, args?: CLIArguments): Promise<void> {
-        const version = args?.["tomcat-version"] || config.tomcat.version || "10.1.52";
+    private async handleUninstall(config: AppConfig, args?: CLIArguments, extraArgs: string[] = []): Promise<void> {
+        // Versão pode vir de: flag --tomcat-version, argumento posicional, config, ou padrão
+        const version = args?.["tomcat-version"] || extraArgs[0] || config.tomcat.version || "10.1.52";
         
         const service = new EmbeddedTomcatService({
             version,

package/src/index.ts

@@ -105,7 +105,7 @@ async function main() {
 		if (commandName === "debug") values.debug = true;
 		if (commandName === "run") values.debug = false;
 		
-		await registry.execute(commandName, config, values);
+		await registry.execute(commandName, config, values, positionals);
 	}
 }
 

package/src/services/EmbeddedTomcatService.ts

@@ -1,245 +1,288 @@
 import { Logger } from "../utils/ui";
-import { existsSync, mkdirSync, createWriteStream, writeFileSync, promises as fs } from "fs";
+import {
+	existsSync,
+	mkdirSync,
+	createWriteStream,
+	writeFileSync,
+	readdirSync,
+	promises as fsPromises,
+} 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;
+	version?: string;
+	port?: number;
+	webappPath: string;
+	contextPath?: string;
 }
 
 interface DownloadProgress {
-    downloaded: number;
-    total: number;
-    percent: number;
+	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"?>
+	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;
+	}
+
+	/**
+	 * Lista todas as versões instaladas
+	 */
+	static listInstalledVersions(): string[] {
+		const baseDir = path.join(os.homedir(), ".xavva", "tomcat");
+		if (!existsSync(baseDir)) return [];
+
+		const versions: string[] = [];
+		const entries = readdirSync(baseDir, { withFileTypes: true });
+
+		for (const entry of entries) {
+			if (entry.isDirectory()) {
+				const catalinaBat = path.join(
+					baseDir,
+					entry.name,
+					"bin",
+					"catalina.bat",
+				);
+				if (existsSync(catalinaBat)) {
+					versions.push(entry.name);
+				}
+			}
+		}
+
+		return versions.sort();
+	}
+
+	/**
+	 * 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 fsPromises.rename(extractedDir, this.tomcatHome);
+			}
+
+			// Limpa arquivo zip
+			await fsPromises.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 fsPromises.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 fsPromises.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 fsPromises.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 fsPromises.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 fsPromises.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 fsPromises.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 fsPromises.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"
@@ -248,144 +291,146 @@ export class EmbeddedTomcatService {
     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
-        };
-    }
+		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 fsPromises.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/utils/config.ts

@@ -79,7 +79,9 @@ export class ConfigManager {
         // 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");
+        // Versão pode vir de: CLI flag > xavva.json tomcat.version > xavva.json version (legado) > padrão
+        const xavvaTomcatVersion = (xavvaJson as any).tomcat?.version;
+        let embeddedVersion = String(cliValues["tomcat-version"] || xavvaTomcatVersion || 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)) {