@archznn/xavva 2.5.0 → 2.6.0

package/README.md

@@ -1,8 +1,8 @@
 # XAVVA CLI 🚀
 
-> Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows
+> Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows, Linux & macOS
 
-[![Version](https://img.shields.io/badge/version-2.4.0-blue.svg)](https://github.com/leorsousa05/Xavva)
+[![Version](https://img.shields.io/badge/version-2.6.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.
@@ -25,7 +25,7 @@ Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomc
 
 ## 📦 Installation
 
-```powershell
+```bash
 # Via NPM
 npm install -g @archznn/xavva
 
@@ -196,12 +196,14 @@ Create `xavva.json` in your project root:
     "tui": false
   },
   "tomcat": {
-    "path": "C:/apache-tomcat",
+    "path": "/home/user/apache-tomcat",
     "port": 8080
   }
 }
 ```
 
+> **Note:** On Windows use `"path": "C:/apache-tomcat"` format.
+
 ### CLI Options
 
 | Option                 | Description                     |
@@ -224,6 +226,25 @@ Create `xavva.json` in your project root:
 
 ---
 
+## 💻 Platform Support
+
+Xavva works on all major platforms:
+
+| Platform | Status | Notes |
+|----------|--------|-------|
+| Windows  | ✅ Full | PowerShell for system integration |
+| Linux    | ✅ Full | Bash/Zsh auto-configuration |
+| macOS    | ✅ Full | Native terminal support |
+
+### Requirements
+
+- **Bun** runtime (latest version)
+- **Java** 11 or higher (JDK)
+- **Maven** 3.6+ or **Gradle** 7+
+- **Git** (optional, for version info)
+
+---
+
 ## 🏗️ Architecture
 
 Xavva uses a modular service-oriented architecture:

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.5.0",
-	"description": "Ultra-fast CLI tool for Java/Tomcat development on Windows with Hot-Reload and Zero Config.",
+	"version": "2.6.0",
+	"description": "Ultra-fast CLI tool for Java/Tomcat development with Hot-Reload and Zero Config. Supports Windows, Linux and macOS.",
 	"module": "src/index.ts",
 	"type": "module",
 	"bin": {
@@ -19,6 +19,8 @@
 		"gradle",
 		"hot-reload",
 		"windows",
+		"linux",
+		"macos",
 		"cli",
 		"bun"
 	],

package/src/commands/DeployCommand.ts

@@ -7,6 +7,11 @@ import { TomcatService } from "../services/TomcatService";
 import { Logger } from "../utils/ui";
 import { EndpointService } from "../services/EndpointService";
 import { BrowserService } from "../services/BrowserService";
+import {
+	getJavaPath,
+	getWarExtractCommand,
+	isWindows,
+} from "../utils/platform";
 
 export class DeployCommand implements Command {
     constructor(private tomcat: TomcatService, private builder: BuildService) {}
@@ -78,15 +83,28 @@ export class DeployCommand implements Command {
                         Bun.spawnSync(["jar", "xf", artifactInfo.path], { cwd: appWebappPath });
                         Logger.server("extracted WAR");
                     } 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
+                        // Fallback para extração com jar (funciona em todas as plataformas)
+                        if (isWindows()) {
+                            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 {
+                            // Linux/Mac: usa unzip ou jar
+                            try {
+                                Bun.spawnSync(["unzip", "-q", "-o", artifactInfo.path, "-d", appWebappPath]);
+                            } catch {
+                                // Fallback final para jar
+                                Bun.spawnSync(getWarExtractCommand(artifactInfo.path, appWebappPath), {
+                                    cwd: appWebappPath
+                                });
                             }
-                        });
-                        Logger.server("extracted WAR (legacy)");
+                        }
+                        Logger.server("extracted WAR (fallback)");
                     }
                 } else {
                     Logger.server("webapp up to date");
@@ -117,13 +135,7 @@ export class DeployCommand implements Command {
         Logger.config("watch", isWatching);
         Logger.config("debug", config.project.debug ? `port ${config.project.debugPort}` : false);
 
-        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 javaVer = Bun.spawnSync([getJavaPath(), "-version"]);
         const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
         const hasDcevm = ["dcevm", "jetbrains", "trava", "jbr"].some(v => output.includes(v));
         

package/src/commands/DoctorCommand.ts

@@ -4,6 +4,17 @@ import { Logger } from "../utils/ui";
 import fs from "fs";
 import path from "path";
 import os from "os";
+import {
+	getCatalinaScript,
+	getWhichCommand,
+	getJbrDownloadUrl,
+	getTarExtractCommand,
+	getJavaPath,
+	getJavaBinary,
+	isWindows,
+	isLinux,
+	isMacOS,
+} from "../utils/platform";
 
 export class DoctorCommand implements Command {
 	async execute(config: AppConfig, values: CLIArguments = {}): Promise<void> {
@@ -25,7 +36,7 @@ export class DoctorCommand implements Command {
 
 		if (!jvmInfo.dcevm) {
 			Logger.log(
-				`    ${Logger.C.yellow}💡 Dica: Sua JVM não suporta mudanças estruturais (novos métodos/campos).${Logger.C.reset}`,
+				`    ${Logger.C.warning}💡 Dica: Sua JVM não suporta mudanças estruturais (novos métodos/campos).${Logger.C.reset}`,
 			);
 			if (values.fix) {
 				await this.installDCEVM();
@@ -41,12 +52,12 @@ export class DoctorCommand implements Command {
 
 		if (tomcatOk) {
 			const binOk = fs.existsSync(
-				path.join(config.tomcat.path, "bin", "catalina.bat"),
+				path.join(config.tomcat.path, "bin", getCatalinaScript()),
 			);
 			this.check(
 				"Tomcat Bin",
 				binOk,
-				binOk ? "OK" : "catalina.bat não encontrado",
+				binOk ? "OK" : `${getCatalinaScript()} não encontrado`,
 			);
 		}
 
@@ -211,10 +222,7 @@ export class DoctorCommand implements Command {
 
 	private checkBinary(name: string): boolean {
 		try {
-			const proc = Bun.spawnSync([
-				process.platform === "win32" ? "where" : "which",
-				name,
-			]);
+			const proc = Bun.spawnSync(getWhichCommand(name));
 			return proc.exitCode === 0;
 		} catch {
 			return false;
@@ -224,11 +232,7 @@ export class DoctorCommand implements Command {
     private checkJVM(): { name: string, dcevm: boolean } {
         try {
             // Tentar primeiro o binário do JAVA_HOME para evitar cache do Path
-            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;
-            }
+            let javaBin = getJavaPath();
 
             const proc = Bun.spawnSync([javaBin, "-version"]);
             const output = (proc.stderr.toString() + proc.stdout.toString()).toLowerCase();
@@ -251,8 +255,8 @@ export class DoctorCommand implements Command {
         Logger.section("Instalação do JetBrains Runtime (JBR 21)");
         Logger.log("Baixando JDK moderna com DCEVM nativo (JBR 21 SDK)...");
         
-        // URL para o JetBrains Runtime 21 SDK Windows x64
-        const url = "https://cache-redirector.jetbrains.com/intellij-jbr/jbrsdk-21.0.6-windows-x64-b895.97.tar.gz";
+        // URL para o JetBrains Runtime 21 SDK (multiplataforma)
+        const url = getJbrDownloadUrl("21");
         const installDir = path.join(os.homedir(), ".xavva", "jdk-dcevm");
         
         // Limpar instalação anterior se existir
@@ -272,21 +276,15 @@ export class DoctorCommand implements Command {
             
             Logger.success("Download concluído. Extraindo binários...");
             
-            // Usar PowerShell para extrair .tar.gz (nativo no Windows 10/11)
-            const extractCmd = `tar -xzf $env:TAR_PATH -C $env:INSTALL_DIR`;
-            Bun.spawnSync(["powershell", "-command", extractCmd], {
-                env: {
-                    ...process.env,
-                    TAR_PATH: tarPath,
-                    INSTALL_DIR: installDir
-                }
-            });
+            // Extrair .tar.gz usando comando apropriado para a plataforma
+            const extractCmd = getTarExtractCommand(tarPath, installDir);
+            Bun.spawnSync(extractCmd);
             
             fs.rmSync(tarPath);
 
-            // Busca recursiva para encontrar onde está o bin/java.exe
+            // Busca recursiva para encontrar onde está o bin/java
             const findJdkRoot = (dir: string): string | null => {
-                if (fs.existsSync(path.join(dir, "bin", "java.exe"))) return dir;
+                if (fs.existsSync(path.join(dir, "bin", getJavaBinary()))) return dir;
                 const subdirs = fs.readdirSync(dir, { withFileTypes: true })
                     .filter(d => d.isDirectory())
                     .map(d => path.join(dir, d.name));
@@ -299,55 +297,110 @@ export class DoctorCommand implements Command {
 
             const jdkPath = findJdkRoot(installDir) || installDir;
             const binPath = path.join(jdkPath, "bin");
-			            
-			                                    Logger.process("Configurando variáveis de ambiente do SISTEMA...");
-			                        
-			                                                const setEnvCmd = `
-			                                                    $jdk = $env:JDK_PATH;
-			                                                    $bin = $env:BIN_PATH;
-			                                                    try {
-			                                                        [Environment]::SetEnvironmentVariable('JAVA_HOME', $jdk, 'Machine');
-			                                                        $pathVar = [Environment]::GetEnvironmentVariable('Path', 'Machine');
-			                                                        $paths = $pathVar -split ';' | Where-Object { $_ -ne '' };
-			                                                        $normalizedBin = $bin.TrimEnd('\\').ToLower();
-			                                                        
-			                                                        $exists = $false;
-			                                                        foreach ($p in $paths) {
-			                                                            if ($p.TrimEnd('\\').ToLower() -eq $normalizedBin) { $exists = $true; break; }
-			                                                        }
-			                                    
-			                                                        if (-not $exists) {
-			                                                            $newPath = "$bin;" + $pathVar;
-			                                                            [Environment]::SetEnvironmentVariable('Path', $newPath, 'Machine');
-			                                                        }
-			                                                        Write-Output "OK";
-			                                                    } catch {
-			                                                        Write-Error $_.Exception.Message;
-			                                                    }
-			                                                `.replace(/\n/g, ' ');
-			                                    			                                    const result = Bun.spawnSync(["powershell", "-command", setEnvCmd], {
-                                                                            env: {
-                                                                                ...process.env,
-                                                                                JDK_PATH: jdkPath,
-                                                                                BIN_PATH: binPath
-                                                                            }
-                                                                        });
-			                                    const output = result.stdout.toString() + result.stderr.toString();
-			                        
-			                                    if (output.includes("ACCESS_DENIED")) {
-			                                        Logger.error("Falha ao configurar variáveis do SISTEMA (Acesso Negado).");
-			                                        Logger.warn("Dica: Execute o terminal como ADMINISTRADOR para permitir esta alteração.");
-			                                        Logger.info("JAVA_HOME manual", jdkPath);
-			                                    } else {
-			                                        Logger.success(`DCEVM configurado no SISTEMA com sucesso!`);
-			                                        Logger.info("JAVA_HOME", jdkPath);
-			                                    }
-			                        
-			                                    Logger.newline();
-			                                    Logger.warn("IMPORTANTE: Reinicie seu terminal (ou o VS Code) para as mudanças surtirem efeito.");
-			                                } catch (e) {
-			                        
-			            			Logger.error(`Falha na instalação: ${e.message}`);
-		}
-	}
+            
+            if (isWindows()) {
+                await this.configureWindowsEnv(jdkPath, binPath);
+            } else {
+                await this.configureUnixEnv(jdkPath, binPath);
+            }
+        } catch (e: any) {
+            Logger.error(`Falha na instalação: ${e.message}`);
+        }
+    }
+
+    private async configureWindowsEnv(jdkPath: string, binPath: string) {
+        Logger.process("Configurando variáveis de ambiente do SISTEMA...");
+
+        const setEnvCmd = `
+            $jdk = $env:JDK_PATH;
+            $bin = $env:BIN_PATH;
+            try {
+                [Environment]::SetEnvironmentVariable('JAVA_HOME', $jdk, 'Machine');
+                $pathVar = [Environment]::GetEnvironmentVariable('Path', 'Machine');
+                $paths = $pathVar -split ';' | Where-Object { $_ -ne '' };
+                $normalizedBin = $bin.TrimEnd('\\\\').ToLower();
+                
+                $exists = $false;
+                foreach ($p in $paths) {
+                    if ($p.TrimEnd('\\\\').ToLower() -eq $normalizedBin) { $exists = $true; break; }
+                }
+
+                if (-not $exists) {
+                    $newPath = "$bin;" + $pathVar;
+                    [Environment]::SetEnvironmentVariable('Path', $newPath, 'Machine');
+                }
+                Write-Output "OK";
+            } catch {
+                Write-Error $_.Exception.Message;
+            }
+        `.replace(/\n/g, ' ');
+
+        const result = Bun.spawnSync(["powershell", "-command", setEnvCmd], {
+            env: {
+                ...process.env,
+                JDK_PATH: jdkPath,
+                BIN_PATH: binPath
+            }
+        });
+        const output = result.stdout.toString() + result.stderr.toString();
+
+        if (output.includes("ACCESS_DENIED")) {
+            Logger.error("Falha ao configurar variáveis do SISTEMA (Acesso Negado).");
+            Logger.warn("Dica: Execute o terminal como ADMINISTRADOR para permitir esta alteração.");
+            Logger.info("JAVA_HOME manual", jdkPath);
+        } else {
+            Logger.success(`DCEVM configurado no SISTEMA com sucesso!`);
+            Logger.info("JAVA_HOME", jdkPath);
+        }
+
+        Logger.newline();
+        Logger.warn("IMPORTANTE: Reinicie seu terminal (ou o VS Code) para as mudanças surtirem efeito.");
+    }
+
+    private async configureUnixEnv(jdkPath: string, binPath: string) {
+        Logger.process("Configurando variáveis de ambiente...");
+
+        const shell = process.env.SHELL || "/bin/bash";
+        let rcFile = path.join(os.homedir(), ".bashrc");
+        
+        if (shell.includes("zsh")) {
+            rcFile = path.join(os.homedir(), ".zshrc");
+        } else if (shell.includes("fish")) {
+            rcFile = path.join(os.homedir(), ".config/fish/config.fish");
+        }
+
+        // Verifica se já existe JAVA_HOME configurado
+        const exportLine = `export JAVA_HOME="${jdkPath}"`;
+        const pathLine = `export PATH="${binPath}:$PATH"`;
+
+        let rcContent = "";
+        if (fs.existsSync(rcFile)) {
+            rcContent = fs.readFileSync(rcFile, "utf8");
+        }
+
+        // Remove linhas antigas do Xavva JBR
+        const lines = rcContent.split("\n");
+        const filteredLines = lines.filter(line => 
+            !line.includes("# Xavva JBR") && 
+            !line.includes("JAVA_HOME=") &&
+            !line.includes("# Added by Xavva")
+        );
+
+        // Adiciona novas configurações
+        filteredLines.push("# Added by Xavva - JetBrains Runtime (DCEVM)");
+        filteredLines.push(exportLine);
+        filteredLines.push(pathLine);
+
+        fs.writeFileSync(rcFile, filteredLines.join("\n") + "\n");
+
+        Logger.success(`DCEVM configurado em ${rcFile}`);
+        Logger.info("JAVA_HOME", jdkPath);
+        Logger.newline();
+        Logger.warn("IMPORTANTE: Execute 'source " + rcFile + "' ou reinicie seu terminal para aplicar permanentemente.");
+        Logger.info("Dica", "Para esta sessão, o JAVA_HOME já foi configurado temporariamente.");
+        
+        // Configura JAVA_HOME temporariamente para o processo atual
+        process.env.JAVA_HOME = jdkPath;
+        process.env.PATH = `${binPath}:${process.env.PATH}`;
+    }
 }

package/src/commands/LogsCommand.ts

@@ -60,7 +60,7 @@ export class LogsCommand implements Command {
                     currentSize = newStats.size;
                 } else if (newStats.size < currentSize) {
                     currentSize = newStats.size;
-                    dashboard.log(Logger.C.yellow + "Arquivo de log foi resetado/rotacionado.");
+                    dashboard.log(Logger.C.warning + "Arquivo de log foi resetado/rotacionado.");
                 }
             }
         });

package/src/commands/RunCommand.ts

@@ -5,6 +5,14 @@ import path from "path";
 import fs from "fs";
 import { glob } from "glob";
 import readline from "readline";
+import {
+	getJavaPath,
+	getMavenCommand,
+	getGradleCommand,
+	getClasspathSeparator,
+	normalizeClasspathPath,
+	isWindows,
+} from "../utils/platform";
 
 export class RunCommand implements Command {
     async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
@@ -36,7 +44,8 @@ export class RunCommand implements Command {
         const { localCp, dependencyCp } = await this.getClasspath(config);
         const pathingJar = await this.createPathingJar(dependencyCp);
         
-        const finalCp = `${localCp};${pathingJar}`;
+        const sep = getClasspathSeparator();
+        const finalCp = `${localCp}${sep}${pathingJar}`;
 
         const javaArgs = [
             "-classpath", finalCp,
@@ -60,7 +69,7 @@ export class RunCommand implements Command {
             Logger.warn(`🚀 Executando ${className}...`);
         }
 
-        const bin = process.env.JAVA_HOME ? path.join(process.env.JAVA_HOME, "bin", "java.exe") : "java";
+        const bin = getJavaPath();
         
         const proc = Bun.spawn([bin, ...javaArgs], {
             stdout: "inherit",
@@ -220,9 +229,10 @@ export class RunCommand implements Command {
         const xavvaDir = path.join(process.cwd(), ".xavva");
         const jarPath = path.join(xavvaDir, "classpath.jar");
 
-        const paths = dependencyCp.split(";").filter(p => p.trim());
+        const sep = getClasspathSeparator();
+        const paths = dependencyCp.split(sep).filter(p => p.trim());
         const relativePaths = paths.map(p => {
-            let rel = path.relative(xavvaDir, p).replace(/\\/g, "/");
+            let rel = normalizeClasspathPath(path.relative(xavvaDir, p));
             if (fs.existsSync(p) && fs.statSync(p).isDirectory() && !rel.endsWith("/")) rel += "/";
             // Robust URL encoding for Class-Path as per Java Spec
             return encodeURI(rel)
@@ -296,10 +306,9 @@ export class RunCommand implements Command {
             const stopSpinner = Logger.spinner("Generating project classpath");
             try {
                 if (config.project.buildTool === "maven") {
-                    const mvnCmd = process.platform === "win32" ? "mvn.cmd" : "mvn";
-                    Bun.spawnSync([mvnCmd, "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
+                    Bun.spawnSync([getMavenCommand(), "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
                 } else if (config.project.buildTool === "gradle") {
-                    const gradleCmd = process.platform === "win32" ? "gradle.bat" : "gradle";
+                    const gradleCmd = getGradleCommand();
                     const initScriptPath = path.join(xavvaDir, "init-cp.gradle");
                     const normalizedCpFile = cpFile.replace(/\\/g, "/");
                     const initScriptContent = `
@@ -335,9 +344,10 @@ export class RunCommand implements Command {
 
         let dependencyCp = fs.existsSync(cpFile) ? fs.readFileSync(cpFile, "utf8").trim() : "";
         
-        // Normalize platform specific separators to semicolon for consistency
-        if (path.delimiter !== ";") {
-            dependencyCp = dependencyCp.split(path.delimiter).join(";");
+        // Normalize platform specific separators para o separador consistente
+        const sep = getClasspathSeparator();
+        if (path.delimiter !== sep) {
+            dependencyCp = dependencyCp.split(path.delimiter).join(sep);
         }
 
         const localFolders = [
@@ -356,7 +366,7 @@ export class RunCommand implements Command {
         const localCp = localFolders
             .map(p => path.join(process.cwd(), p))
             .filter(p => fs.existsSync(p))
-            .join(";");
+            .join(getClasspathSeparator());
 
         return { localCp, dependencyCp };
     }

package/src/index.ts

@@ -93,7 +93,7 @@ async function main() {
 		// Registrar ação de restart manual na TUI
 		if (dashboard.isTuiActive()) {
 			dashboard.onAction("r", () => {
-				dashboard.log(Logger.C.yellow + "Restart manual solicitado via TUI...");
+				dashboard.log(Logger.C.warning + "Restart manual solicitado via TUI...");
 				deployCmd.execute(config, false, true); // Executa deploy completo mas mantém o watch
 			});
 		}

package/src/services/BrowserService.ts

@@ -1,15 +1,22 @@
 import { Logger } from "../utils/ui";
+import { isWindows, getOpenBrowserArgs } from "../utils/platform";
 
 export class BrowserService {
     /**
-     * Recarrega a aba ativa do browser (Chrome ou Edge) no Windows.
+     * Recarrega a aba ativa do browser (Chrome ou Edge).
+     * Nota: No Linux/Mac, esta funcionalidade é limitada devido às restrições
+     * de automação de GUI. Recomenda-se usar extensões de Live Reload.
      */
     public static async reload(url: string) {
-        if (process.platform !== 'win32') return;
-        
         // Pequeno delay para garantir que o Tomcat processou o novo contexto
         await new Promise(r => setTimeout(r, 800));
 
+        if (!isWindows()) {
+            // No Linux/Mac, tenta notificar via Browser Sync ou similar se disponível
+            // Por enquanto, apenas loga (o usuário pode usar extensões de Live Reload)
+            return;
+        }
+
         const psCommand = `
             $shell = New-Object -ComObject WScript.Shell
             $process = Get-Process | Where-Object { $_.MainWindowTitle -match "Chrome" -or $_.MainWindowTitle -match "Edge" } | Select-Object -First 1
@@ -31,11 +38,7 @@ export class BrowserService {
      * Abre a URL no browser padrão do sistema.
      */
     public static open(url: string) {
-        if (process.platform === 'win32') {
-            Bun.spawn(["cmd", "/c", "start", url]);
-        } else {
-            const start = process.platform === 'darwin' ? 'open' : 'xdg-open';
-            Bun.spawn([start, url]);
-        }
+        const args = getOpenBrowserArgs(url);
+        Bun.spawn(args);
     }
 }

package/src/services/BuildService.ts

@@ -30,6 +30,11 @@ export class BuildService {
 			this.cache.clearCache();
 		}
 
+		// Sempre limpa a pasta de build antes (target/ ou build/)
+		if (!incremental) {
+			await this.cleanBuildDirectory();
+		}
+
 		// Cache só é usado se --cache for passado ou em modo incremental
 		const useCache = this.projectConfig.cache || incremental;
 		
@@ -54,7 +59,8 @@ export class BuildService {
 			if (incremental) {
 				command.push("compile");
 			} else {
-				if (this.projectConfig.clean) command.push("clean");
+				// Sempre executa clean antes do build
+				command.push("clean");
 				// Use 'package' para gerar .war ou 'war:exploded' para pasta
 				if (this.projectConfig.war) {
 					command.push("package");
@@ -76,7 +82,8 @@ export class BuildService {
 			if (incremental) {
 				command.push("classes");
 			} else {
-				if (this.projectConfig.clean) command.push("clean");
+				// Sempre executa clean antes do build
+				command.push("clean");
 				command.push("war");
 				command.push("--parallel", "--build-cache");
 			}
@@ -123,6 +130,26 @@ export class BuildService {
 		}
 	}
 
+	/**
+	 * Limpa fisicamente o diretório de build (target/ ou build/)
+	 * Garante build limpo antes de cada execução
+	 */
+	private async cleanBuildDirectory(): Promise<void> {
+		const buildDir = this.projectConfig.buildTool === 'maven' 
+			? path.join(process.cwd(), 'target')
+			: path.join(process.cwd(), 'build');
+		
+		if (existsSync(buildDir)) {
+			try {
+				Logger.step(`Cleaning ${path.basename(buildDir)}/ directory...`);
+				await fs.rm(buildDir, { recursive: true, force: true });
+				Logger.debug(`Removed ${buildDir}`);
+			} catch (e) {
+				Logger.warn(`Could not fully remove ${buildDir}, continuing...`);
+			}
+		}
+	}
+
 	async syncExploded(srcDir: string, destDir: string): Promise<void> {
 		if (!existsSync(srcDir)) return;
 		if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });

package/src/services/EmbeddedTomcatService.ts

@@ -10,6 +10,17 @@ import {
 import path from "path";
 import os from "os";
 import { spawn } from "child_process";
+import {
+	getPlatform,
+	isWindows,
+	getTomcatArchiveName,
+	getTomcatDownloadUrl,
+	getTomcatArchiveUrl,
+	getExtractCommand,
+	getPortCheckCommand,
+	getCatalinaScript,
+	hasCatalinaScript,
+} from "../utils/platform";
 
 export interface EmbeddedTomcatOptions {
 	version?: string;
@@ -35,20 +46,18 @@ export class EmbeddedTomcatService {
 	private isInstalled: boolean = false;
 
 	// Versões estáveis do Tomcat (atualizadas: 2026-03-04)
+	// URLs são construídas dinamicamente baseadas na plataforma
 	private static readonly VERSIONS: Record<
 		string,
-		{ url: string; sha512: 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: "",
 			},
 		};
@@ -61,14 +70,14 @@ export class EmbeddedTomcatService {
 		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
+		// Constrói URL de download baseada na plataforma
 		const versionInfo = EmbeddedTomcatService.VERSIONS[this.version];
 		if (versionInfo) {
-			this.downloadUrl = versionInfo.url;
+			// Usa URL primária (CDN Apache)
+			this.downloadUrl = getTomcatDownloadUrl(this.version);
 		} 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`;
+			// Tenta inferir URL baseado no padrão Apache (archive)
+			this.downloadUrl = getTomcatArchiveUrl(this.version);
 		}
 	}
 
@@ -76,8 +85,7 @@ export class EmbeddedTomcatService {
 	 * Verifica se o Tomcat já está instalado
 	 */
 	checkInstallation(): boolean {
-		const catalinaBat = path.join(this.tomcatHome, "bin", "catalina.bat");
-		this.isInstalled = existsSync(catalinaBat);
+		this.isInstalled = hasCatalinaScript(this.tomcatHome);
 		return this.isInstalled;
 	}
 
@@ -100,13 +108,8 @@ export class EmbeddedTomcatService {
 
 		for (const entry of entries) {
 			if (entry.isDirectory()) {
-				const catalinaBat = path.join(
-					baseDir,
-					entry.name,
-					"bin",
-					"catalina.bat",
-				);
-				if (existsSync(catalinaBat)) {
+				const tomcatPath = path.join(baseDir, entry.name);
+				if (hasCatalinaScript(tomcatPath)) {
 					versions.push(entry.name);
 				}
 			}
@@ -133,10 +136,8 @@ export class EmbeddedTomcatService {
 			mkdirSync(this.baseDir, { recursive: true });
 		}
 
-		const zipPath = path.join(
-			this.baseDir,
-			`apache-tomcat-${this.version}.zip`,
-		);
+		const archiveName = getTomcatArchiveName(this.version);
+		const zipPath = path.join(this.baseDir, archiveName);
 
 		try {
 			// Download
@@ -300,21 +301,24 @@ export class EmbeddedTomcatService {
 	 */
 	async isPortAvailable(): Promise<boolean> {
 		return new Promise((resolve) => {
-			const netstat = spawn("cmd", [
-				"/c",
-				`netstat -ano | findstr :${this.port}`,
-			]);
+			const cmd = getPortCheckCommand(this.port);
+			const checkProcess = spawn(cmd[0], cmd.slice(1));
 			let output = "";
 
-			netstat.stdout?.on("data", (data) => {
+			checkProcess.stdout?.on("data", (data) => {
+				output += data.toString();
+			});
+
+			checkProcess.stderr?.on("data", (data) => {
 				output += data.toString();
 			});
 
-			netstat.on("close", () => {
+			checkProcess.on("close", () => {
+				// Se houver output, a porta está em uso
 				resolve(output.trim().length === 0);
 			});
 
-			netstat.on("error", () => {
+			checkProcess.on("error", () => {
 				resolve(true); // Assume disponível se não conseguir verificar
 			});
 		});
@@ -382,18 +386,23 @@ export class EmbeddedTomcatService {
 	}
 
 	/**
-	 * Extrai arquivo ZIP usando PowerShell
+	 * Extrai arquivo de arquivos (ZIP ou tar.gz)
 	 */
 	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`,
-			]);
+			const cmd = getExtractCommand(zipPath, destDir);
+			
+			if (!cmd) {
+				spinner(false);
+				reject(new Error(`Formato de arquivo não suportado: ${path.extname(zipPath)}`));
+				return;
+			}
+
+			const extractProcess = spawn(cmd[0], cmd.slice(1));
 
-			ps.on("close", (code) => {
+			extractProcess.on("close", (code) => {
 				if (code === 0) {
 					spinner(true);
 					resolve();
@@ -403,7 +412,7 @@ export class EmbeddedTomcatService {
 				}
 			});
 
-			ps.on("error", (err) => {
+			extractProcess.on("error", (err) => {
 				spinner(false);
 				reject(err);
 			});

package/src/services/LogAnalyzer.ts

@@ -77,7 +77,7 @@ export class LogAnalyzer {
         const isProject = this.projectPrefixes.some(p => trimmed.includes(p));
         
         if (isProject) {
-            return `    ${Logger.C.bold}${Logger.C.yellow}${trimmed}${Logger.C.reset}`;
+            return `    ${Logger.C.bold}${Logger.C.warning}${trimmed}${Logger.C.reset}`;
         } else {
             return `    ${Logger.C.dim}${trimmed}${Logger.C.reset}`;
         }
@@ -100,7 +100,7 @@ export class LogAnalyzer {
 
         let color = Logger.C.primary;
         let symbol = "●";
-        if (level === "WARN") { color = Logger.C.yellow; symbol = "▲"; }
+        if (level === "WARN") { color = Logger.C.warning; symbol = "▲"; }
         else if (level === "ERROR") { color = Logger.C.red; symbol = "✖"; }
         
         return `${color}${symbol} ${Logger.C.bold}Hotswap:${Logger.C.reset} ${msg}`;
@@ -113,7 +113,7 @@ export class LogAnalyzer {
         
         let color = Logger.C.dim;
         let symbol = "ℹ";
-        if (label === "WARNING") { color = Logger.C.yellow; symbol = "▲"; }
+        if (label === "WARNING") { color = Logger.C.warning; symbol = "▲"; }
         else if (label === "SEVERE" || label === "ERROR") { color = Logger.C.red; symbol = "✖"; }
         
         msg = msg.replace(/^(org\.apache|com\.sun|java\..*?|org\.glassfish)\.[a-zA-Z0-9.]+\s/, "").trim();
@@ -129,7 +129,7 @@ export class LogAnalyzer {
         
         let color = Logger.C.dim;
         let symbol = "ℹ";
-        if (label === "WARNING" || label === "WARN") { color = Logger.C.yellow; symbol = "▲"; }
+        if (label === "WARNING" || label === "WARN") { color = Logger.C.warning; symbol = "▲"; }
         else if (label === "SEVERE" || label === "ERROR") { color = Logger.C.red; symbol = "✖"; }
         
         msg = msg.replace(/^(org\.apache|com\.sun|java\..*?)\.[a-zA-Z0-9.]+\s/, "").trim();

package/src/services/TomcatService.ts

@@ -5,6 +5,14 @@ import { ProjectService } from "./ProjectService";
 import { existsSync, mkdirSync, writeFileSync, statSync, promises as fs } from "fs";
 import path from "path";
 import os from "os";
+import {
+	getCatalinaPath,
+	getMemoryCommand,
+	getKillCommand,
+	getPortCheckCommand,
+	getJavaPath,
+	isWindows,
+} from "../utils/platform";
 
 export class TomcatService {
 	private activeConfig: TomcatConfig;
@@ -25,23 +33,55 @@ export class TomcatService {
 	async getMemoryUsage(): Promise<string> {
 		if (!this.pid) return "0 MB";
 		try {
-			const { stdout } = Bun.spawnSync(["powershell", "-command", `(Get-Process -Id ${this.pid}).WorkingSet64 / 1MB`]);
+			const cmd = getMemoryCommand(this.pid);
+			if (!cmd) return "N/A";
+			
+			const { stdout } = Bun.spawnSync(cmd);
 			const mem = await new Response(stdout).text();
-			return `${Math.round(parseFloat(mem))} MB`;
+			const memValue = parseFloat(mem.trim());
+			
+			if (isNaN(memValue)) return "N/A";
+			
+			// No Linux/macOS, ps retorna em KB, convertemos para MB
+			if (!isWindows()) {
+				return `${Math.round(memValue / 1024)} MB`;
+			}
+			
+			return `${Math.round(memValue)} MB`;
 		} catch (e) {
 			return "N/A";
 		}
 	}
 
 	async killConflict() {
-		const { stdout } = Bun.spawnSync(["cmd", "/c", `netstat -ano | findstr :${this.activeConfig.port}`]);
+		const cmd = getPortCheckCommand(this.activeConfig.port);
+		const { stdout } = Bun.spawnSync(cmd);
 		const output = await new Response(stdout).text();
 
 		if (output) {
-			const lines = output.trim().split('\n');
-			const pid = lines[0].trim().split(/\s+/).pop();
-			Logger.step(`Freeing port ${this.activeConfig.port}`);
-			Bun.spawnSync(["taskkill", "/F", "/PID", pid]);
+			// Extrai PID do output
+			let pid: string | undefined;
+			
+			if (isWindows()) {
+				// Windows: netstat output, última coluna é o PID
+				const lines = output.trim().split('\n');
+				pid = lines[0].trim().split(/\s+/).pop();
+			} else {
+				// Linux/Mac: tenta extrair PID de lsof, ss ou netstat
+				// lsof -i :port: formato tem PID na coluna 2
+				// ss -tlnp: tem pid=XXXX
+				// netstat -tlnp: tem /XXXX no final
+				const match = output.match(/\b(\d+)\b/) || // número isolado (lsof)
+							  output.match(/pid=(\d+)/) ||     // ss format
+							  output.match(/\/(\d+)/);         // netstat format
+				if (match) pid = match[1];
+			}
+			
+			if (pid) {
+				Logger.step(`Freeing port ${this.activeConfig.port}`);
+				const killCmd = getKillCommand(pid);
+				Bun.spawnSync(killCmd);
+			}
 		}
 	}
 
@@ -105,21 +145,54 @@ export class TomcatService {
 			
 			Logger.step("Downloading HotswapAgent v2.0.3 (Global)...");
 			const url = "https://github.com/HotswapProjects/HotswapAgent/releases/download/RELEASE-2.0.3/hotswap-agent-2.0.3.jar";
-			const response = await fetch(url);
-			if (!response.ok) throw new Error(`Status: ${response.status}`);
+			
+			Logger.debug(`URL: ${url}`);
+			Logger.debug(`Destino: ${agentPath}`);
+			
+			const response = await fetch(url, {
+				redirect: "follow",
+			});
+			
+			if (!response.ok) {
+				throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+			}
+			
+			const contentLength = response.headers.get("content-length");
+			Logger.debug(`Content-Length: ${contentLength || "unknown"}`);
 			
 			const buffer = await response.arrayBuffer();
+			Logger.debug(`Downloaded: ${buffer.byteLength} bytes`);
+			
+			if (buffer.byteLength < 1000) {
+				throw new Error(`Arquivo muito pequeno (${buffer.byteLength} bytes)`);
+			}
+			
 			writeFileSync(agentPath, Buffer.from(buffer));
+			
+			// Verifica se foi escrito corretamente
+			const stats = statSync(agentPath);
+			Logger.debug(`Escrito: ${stats.size} bytes`);
+			
 			Logger.success("HotswapAgent v2.0.3 installed globally!");
 			return agentPath;
-		} catch (e) {
-			Logger.warn("Falha ao baixar HotswapAgent. Usando hot swap padrão da JVM.");
+		} catch (e: any) {
+			Logger.warn(`Falha ao baixar HotswapAgent: ${e.message}`);
+			Logger.warn("Usando hot swap padrão da JVM.");
+			
+			// Limpa arquivo parcial se existir
+			if (existsSync(agentPath)) {
+				try {
+					await fs.unlink(agentPath);
+					Logger.debug("Arquivo parcial removido");
+				} catch {}
+			}
+			
 			return null;
 		}
 	}
 
 	async start(config: AppConfig, isWatching: boolean = false) {
-		const binPath = `${this.activeConfig.path}\\bin\\catalina.bat`;
+		const binPath = getCatalinaPath(this.activeConfig.path);
 		const args = (config.project.debug || isWatching) ? ["jpda", "run"] : ["run"];
 		
 		const catalinaOpts = [process.env.CATALINA_OPTS || ""];
@@ -134,7 +207,7 @@ export class TomcatService {
 					javaBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
 				}
 
-				const javaVer = Bun.spawnSync([javaBin, "-version"]);
+				const javaVer = Bun.spawnSync([getJavaPath(), "-version"]);
 				const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
 				
 				if (output.includes("dcevm") || output.includes("jbr") || output.includes("trava")) {

package/src/utils/platform.ts

@@ -0,0 +1,323 @@
+/**
+ * Platform Utilities - Helpers para detecção e adaptação multiplataforma
+ * 
+ * Centraliza toda a lógica de diferenciação entre Windows, Linux e macOS.
+ */
+
+import os from "os";
+import path from "path";
+
+export type Platform = "win32" | "linux" | "darwin";
+
+/**
+ * Retorna a plataforma atual normalizada
+ */
+export function getPlatform(): Platform {
+    const platform = process.platform;
+    if (platform === "win32") return "win32";
+    if (platform === "darwin") return "darwin";
+    return "linux";
+}
+
+/**
+ * Verifica se está rodando no Windows
+ */
+export function isWindows(): boolean {
+    return getPlatform() === "win32";
+}
+
+/**
+ * Verifica se está rodando no Linux
+ */
+export function isLinux(): boolean {
+    return getPlatform() === "linux";
+}
+
+/**
+ * Verifica se está rodando no macOS
+ */
+export function isMacOS(): boolean {
+    return getPlatform() === "darwin";
+}
+
+/**
+ * Retorna a extensão de script apropriada (.bat para Windows, .sh para Unix)
+ */
+export function getScriptExt(): string {
+    return isWindows() ? ".bat" : ".sh";
+}
+
+/**
+ * Retorna o nome do binário Java apropriado (java.exe para Windows, java para Unix)
+ */
+export function getJavaBinary(): string {
+    return isWindows() ? "java.exe" : "java";
+}
+
+/**
+ * Retorna o caminho completo para o binário Java se JAVA_HOME estiver definido
+ */
+export function getJavaPath(): string {
+    if (process.env.JAVA_HOME) {
+        const javaBin = path.join(process.env.JAVA_HOME, "bin", getJavaBinary());
+        return javaBin;
+    }
+    return getJavaBinary();
+}
+
+/**
+ * Retorna o script catalina apropriado (catalina.bat ou catalina.sh)
+ */
+export function getCatalinaScript(): string {
+    return `catalina${getScriptExt()}`;
+}
+
+/**
+ * Retorna o script startup apropriado
+ */
+export function getStartupScript(): string {
+    return `startup${getScriptExt()}`;
+}
+
+/**
+ * Retorna o script shutdown apropriado
+ */
+export function getShutdownScript(): string {
+    return `shutdown${getScriptExt()}`;
+}
+
+/**
+ * Retorna o comando Maven apropriado
+ */
+export function getMavenCommand(): string {
+    return isWindows() ? "mvn.cmd" : "mvn";
+}
+
+/**
+ * Retorna o comando Gradle apropriado
+ */
+export function getGradleCommand(): string {
+    return isWindows() ? "gradle.bat" : "gradle";
+}
+
+/**
+ * Retorna a extensão de arquivo de download do Tomcat (.zip para Windows, .tar.gz para Unix)
+ */
+export function getTomcatArchiveExt(): string {
+    return isWindows() ? ".zip" : ".tar.gz";
+}
+
+/**
+ * Retorna o nome do arquivo do Tomcat para download
+ */
+export function getTomcatArchiveName(version: string): string {
+    const baseName = `apache-tomcat-${version}`;
+    if (isWindows()) {
+        return `${baseName}-windows-x64.zip`;
+    }
+    if (isMacOS()) {
+        // macOS usa a mesma versão do Linux (tar.gz)
+        return `${baseName}.tar.gz`;
+    }
+    return `${baseName}.tar.gz`;
+}
+
+/**
+ * Retorna a URL de download do Tomcat baseada na versão e plataforma
+ */
+export function getTomcatDownloadUrl(version: string): string {
+    const majorVersion = version.split(".")[0];
+    const archiveName = getTomcatArchiveName(version);
+    
+    // URL primária (CDN Apache)
+    return `https://dlcdn.apache.org/tomcat/tomcat-${majorVersion}/v${version}/bin/${archiveName}`;
+}
+
+/**
+ * Retorna a URL alternativa (archive) caso a primária falhe
+ */
+export function getTomcatArchiveUrl(version: string): string {
+    const majorVersion = version.split(".")[0];
+    const archiveName = getTomcatArchiveName(version);
+    
+    // URL alternativa (archive Apache)
+    return `https://archive.apache.org/dist/tomcat/tomcat-${majorVersion}/v${version}/bin/${archiveName}`;
+}
+
+/**
+ * Retorna o comando para extrair um arquivo
+ * Retorna null se não for possível determinar
+ */
+export function getExtractCommand(archivePath: string, destDir: string): string[] | null {
+    if (isWindows()) {
+        // Windows: usa PowerShell para extrair
+        if (archivePath.endsWith(".zip")) {
+            return [
+                "powershell",
+                "-command",
+                `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`,
+            ];
+        }
+        // Para .tar.gz no Windows (PowerShell 5.1+)
+        if (archivePath.endsWith(".tar.gz") || archivePath.endsWith(".tgz")) {
+            return [
+                "powershell",
+                "-command",
+                `tar -xzf '${archivePath}' -C '${destDir}'`,
+            ];
+        }
+    } else {
+        // Linux/Mac: usa tar
+        if (archivePath.endsWith(".tar.gz") || archivePath.endsWith(".tgz")) {
+            return ["tar", "-xzf", archivePath, "-C", destDir];
+        }
+        // Para .zip no Linux/Mac
+        if (archivePath.endsWith(".zip")) {
+            // Tenta unzip primeiro, depois tar
+            return ["unzip", "-q", "-o", archivePath, "-d", destDir];
+        }
+    }
+    return null;
+}
+
+/**
+ * Retorna o comando para verificar se uma porta está em uso
+ */
+export function getPortCheckCommand(port: number): string[] {
+    if (isWindows()) {
+        return ["cmd", "/c", `netstat -ano | findstr :${port}`];
+    }
+    // Linux/Mac: tenta lsof, ss, ou netstat
+    // Preferência por lsof (mais comum)
+    return ["sh", "-c", `lsof -i :${port} 2>/dev/null || ss -tlnp 2>/dev/null | grep ':${port}' || netstat -tlnp 2>/dev/null | grep ':${port}'`];
+}
+
+/**
+ * Retorna o comando para matar um processo pelo PID
+ */
+export function getKillCommand(pid: number | string): string[] {
+    if (isWindows()) {
+        return ["taskkill", "/F", "/PID", String(pid)];
+    }
+    return ["kill", "-9", String(pid)];
+}
+
+/**
+ * Retorna o comando para obter uso de memória de um processo
+ */
+export function getMemoryCommand(pid: number): string[] | null {
+    if (isWindows()) {
+        return [
+            "powershell",
+            "-command",
+            `(Get-Process -Id ${pid}).WorkingSet64 / 1MB`,
+        ];
+    }
+    // Linux: /proc/<pid>/status tem VmRSS em kB
+    if (isLinux()) {
+        return ["sh", "-c", `cat /proc/${pid}/status 2>/dev/null | grep VmRSS | awk '{print int($2/1024)}'`];
+    }
+    // macOS: usa ps
+    if (isMacOS()) {
+        return ["ps", "-o", "rss=", "-p", String(pid)];
+    }
+    return null;
+}
+
+/**
+ * Retorna o comando para abrir uma URL no navegador padrão
+ */
+export function getOpenBrowserCommand(): string {
+    if (isWindows()) {
+        return "start";
+    }
+    if (isMacOS()) {
+        return "open";
+    }
+    return "xdg-open";
+}
+
+/**
+ * Retorna o comando para abrir uma URL no navegador (array para spawn)
+ */
+export function getOpenBrowserArgs(url: string): string[] {
+    const cmd = getOpenBrowserCommand();
+    if (isWindows()) {
+        // Windows: start "" "url" (o "" é necessário para títulos de janela)
+        return [cmd, "", url];
+    }
+    return [cmd, url];
+}
+
+/**
+ * Retorna o comando para encontrar um binário no PATH
+ */
+export function getWhichCommand(binary: string): string[] {
+    if (isWindows()) {
+        return ["where", binary];
+    }
+    return ["which", binary];
+}
+
+/**
+ * Retorna o separador de classpath apropriado
+ */
+export function getClasspathSeparator(): string {
+    return path.delimiter;
+}
+
+/**
+ * Normaliza um caminho para uso em classpath (converte backslash para forward slash)
+ */
+export function normalizeClasspathPath(p: string): string {
+    return p.replace(/\\/g, "/");
+}
+
+/**
+ * Retorna o comando para extrair um WAR/JAR (usando jar ou unzip)
+ */
+export function getWarExtractCommand(warPath: string, destDir: string): string[] {
+    // Tenta usar jar (disponível em qualquer JDK)
+    return ["jar", "xf", warPath];
+}
+
+/**
+ * Retorna a URL de download do JetBrains Runtime (JBR) com DCEVM
+ */
+export function getJbrDownloadUrl(version: string = "21"): string {
+    // JBR 21 é a versão recomendada
+    if (isWindows()) {
+        return `https://cache-redirector.jetbrains.com/intellij-jbr/jbrsdk-${version}.0.6-windows-x64-b895.97.tar.gz`;
+    }
+    if (isMacOS()) {
+        return `https://cache-redirector.jetbrains.com/intellij-jbr/jbrsdk-${version}.0.6-osx-x64-b895.97.tar.gz`;
+    }
+    // Linux x64
+    return `https://cache-redirector.jetbrains.com/intellij-jbr/jbrsdk-${version}.0.6-linux-x64-b895.97.tar.gz`;
+}
+
+/**
+ * Retorna o comando para extrair um .tar.gz
+ */
+export function getTarExtractCommand(tarPath: string, destDir: string): string[] {
+    if (isWindows()) {
+        // Windows 10+ tem tar nativo via PowerShell
+        return ["powershell", "-command", `tar -xzf '${tarPath}' -C '${destDir}'`];
+    }
+    return ["tar", "-xzf", tarPath, "-C", destDir];
+}
+
+/**
+ * Constrói o caminho completo para o script catalina
+ */
+export function getCatalinaPath(tomcatHome: string): string {
+    return path.join(tomcatHome, "bin", getCatalinaScript());
+}
+
+/**
+ * Verifica se o script catalina existe no diretório do Tomcat
+ */
+export function hasCatalinaScript(tomcatHome: string): boolean {
+    const { existsSync } = require("fs");
+    return existsSync(getCatalinaPath(tomcatHome));
+}