@archznn/xavva 2.0.0 → 2.0.2

package/README.md

@@ -1,4 +1,4 @@
-# XAVVA 🚀 (Windows Only) `v2.0.0`
+# XAVVA 🚀 (Windows Only) `v2.0.2`
 
 Xavva é uma CLI de alto desempenho construída com **Bun** para automatizar o ciclo de desenvolvimento de aplicações Java (Maven/Gradle) rodando no Apache Tomcat. Ela foi desenhada especificamente para desenvolvedores que buscam a velocidade de ambientes modernos (como Node.js/Vite) dentro do ecossistema Java Enterprise.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.0.0",
+	"version": "2.0.2",
 	"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/DeployCommand.ts

@@ -62,8 +62,10 @@ export class DeployCommand implements Command {
             const appWebappPath = path.join(config.tomcat.path, "webapps", finalContextPath);
 
             if (artifactInfo.isDirectory) {
-                await builder.syncClasses(artifactInfo.path);
-                Logger.build("Exploded directory synced");
+                // Se é um diretório (exploded), sincronizamos o conteúdo total para a pasta do webapps
+                if (!fs.existsSync(appWebappPath)) fs.mkdirSync(appWebappPath, { recursive: true });
+                await builder.syncExploded(artifactInfo.path, appWebappPath);
+                Logger.build("Exploded directory synced to webapps");
             } else {
                 if (!fs.existsSync(appWebappPath)) fs.mkdirSync(appWebappPath, { recursive: true });
 
@@ -90,6 +92,7 @@ export class DeployCommand implements Command {
                 }
             }
 
+            this.injectContextConfiguration(appWebappPath);
             this.injectHotswapProperties(appWebappPath);
 
             const finalAppUrl = `http://localhost:${config.tomcat.port}/${finalContextPath}`;
@@ -136,6 +139,20 @@ export class DeployCommand implements Command {
         }
     }
 
+    private injectContextConfiguration(appPath: string) {
+        const metaInfPath = path.join(appPath, "META-INF");
+        if (!fs.existsSync(metaInfPath)) fs.mkdirSync(metaInfPath, { recursive: true });
+
+        const contextPath = path.join(metaInfPath, "context.xml");
+        
+        // Aumentamos o cache para 100MB (102400 KB) para evitar avisos de cache insuficiente
+        const contextContent = `<?xml version="1.0" encoding="UTF-8"?>\n<Context>\n    <Resources cachingAllowed="true" cacheMaxSize="102400" />\n</Context>`;
+
+        try {
+            fs.writeFileSync(contextPath, contextContent);
+        } catch (e) {}
+    }
+
     private injectHotswapProperties(appWebappPath: string) {
         const webInfClassesDir = path.join(appWebappPath, "WEB-INF", "classes");
         if (!fs.existsSync(webInfClassesDir)) fs.mkdirSync(webInfClassesDir, { recursive: true });

package/src/commands/HelpCommand.ts

@@ -1,50 +1,48 @@
 import type { Command } from "./Command";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments } from "../types/config";
 import pkg from "../../package.json";
 
 export class HelpCommand implements Command {
-    async execute(_config: AppConfig): Promise<void> {
+    async execute(_config: AppConfig, _args?: CLIArguments): Promise<void> {
         console.log(`
-🛠️  Xavva CLI v${pkg.version}
--------------------------------
-A Xavva automatiza o ciclo de vida de aplicações Java (Tomcat).
-Se nenhum comando for fornecido, 'deploy' será executado por padrão.
+🛠️  XAVVA CLI v${pkg.version} 🚀
+---------------------------------------
+Automatização de alta performance para Java Enterprise (Tomcat) no Windows.
+Detecta automaticamente Maven/Gradle e otimiza o ciclo de desenvolvimento.
 
 Comandos principais:
-  dev           🚀 MODO COMPLETO: Deploy + Watch + Debug + Clean.
-  deploy        (Padrão) Builda o projeto, move para webapps e inicia o Tomcat.
-  start         Apenas inicia o servidor (útil quando o .war já foi gerado).
-  build         Executa apenas a compilação (mvn package ou gradle build).
-  doctor        🩺 Verifica o ambiente (Java, Tomcat, Maven, etc).
-  docs          📖 Swagger-like: Exibe endpoints e URLs de JSPs.
-  audit         🛡️ JAR Audit: Busca vulnerabilidades (CVEs) nas dependências.
-  run           🚀 Executa uma classe main (Uso: xavva run NomeDaClasse).
-  debug         🐞 Debuga uma classe main (Uso: xavva debug NomeDaClasse).
-  logs          📋 Monitora o catalina.out do Tomcat em tempo real.
+  dev           🚀 MODO COMPLETO: Build + Deploy + Watch + Debug.
+  deploy        (Padrão) Compila, sincroniza e inicia o servidor.
+  logs          📋 Tail inteligente (catalina.out) com Smart Folding.
+  run / debug   🚀 Executa classes standalone com Pathing JAR (Windows).
+  doctor        🩺 Diagnóstico e reparo de ambiente (DCEVM, JAVA_HOME).
+  audit         🛡️ Auditoria de segurança em JARs via OSV.dev.
+  docs          📖 Mapeamento estático de Endpoints e JSPs.
+  build / start Comandos granulares de compilação ou startup.
 
-Opções:
-  -w, --watch   👀 Hot Reload: monitora arquivos e redeploya automaticamente.
-  -d, --debug   🐞 Habilita debug Java (JPDA).
-  --dp [porta]  🔌 Porta do Debugger (padrão: 5005).
-  -c, --clean   🧹 Logs coloridos e simplificados (recomendado).
-  -q, --quiet   🤫 Mostra apenas mensagens essenciais nos logs.
-  -V, --verbose 📣 Mostra logs completos do Maven/Gradle.
-  -s, --no-build Pula o build (usa o que já estiver na pasta target/build).
-  -P, --profile Define o profile (ex: -P prod).
-  --fix         🔧 Corrige problemas automaticamente no 'doctor'.
+Opções de Interface:
+  --tui         🖥️  Ativa o Dashboard Interativo (Interface TUI).
+                No modo TUI use: [R] Restart, [L] Clear, [Q] Quit.
+  -w, --watch   👀 Hot Reload: Redeploy incremental de classes e recursos.
+  -c, --clean   🧹 Logs coloridos e simplificados (Recomendado).
+  -V, --verbose 📣 Exibe logs completos do Maven/Gradle.
 
-Exemplos de uso:
-  xavva dev           A melhor experiência de dev local.
-  xavva -w -c         Inicia com auto-reload e logs limpos.
-  xavva deploy -d     Builda e inicia com debugger habilitado.
-  xavva start -c      Apenas sobe o servidor com logs limpos.
-  xavva build -P dev  Apenas compila usando o profile 'dev'.
+Opções de Runtime:
+  -d, --debug   🐞 Habilita JPDA Debugging (Porta 5005).
+  -P, --profile Define o profile de build (ex: -P prod).
+  -s, --no-build Pula o build inicial.
+  --fix         🔧 Corrige problemas automaticamente (Doctor).
 
-Opções de Configuração:
-  -p, --path    Caminho do Tomcat (padrão via config.ts)
-  -t, --tool    Ferramenta (maven/gradle)
-  -n, --name    Nome do .war (ex: -n ROOT)
-  --port        Porta HTTP (padrão: 8080)
+Configuração:
+  O Xavva prioriza o arquivo 'xavva.json' na raiz do projeto.
+  Flags de linha de comando: -p (Tomcat Path), -t (Build Tool), -n (WAR Name).
+
+Exemplos:
+  xavva dev --tui      Experiência completa com Dashboard.
+  xavva run MyClass    Execução standalone com classpath automático.
+  xavva audit          Verifica vulnerabilidades conhecidas.
+
+*Transformando o legado em produtivo.*
         `);
     }
 }

package/src/commands/RunCommand.ts

@@ -295,8 +295,10 @@ export class RunCommand implements Command {
             const stopSpinner = Logger.spinner("Generating project classpath");
             try {
                 if (config.project.buildTool === "maven") {
-                    Bun.spawnSync(["mvn", "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
+                    const mvnCmd = process.platform === "win32" ? "mvn.cmd" : "mvn";
+                    Bun.spawnSync([mvnCmd, "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
                 } else if (config.project.buildTool === "gradle") {
+                    const gradleCmd = process.platform === "win32" ? "gradle.bat" : "gradle";
                     const initScriptPath = path.join(xavvaDir, "init-cp.gradle");
                     const normalizedCpFile = cpFile.replace(/\\/g, "/");
                     const initScriptContent = `
@@ -319,7 +321,7 @@ export class RunCommand implements Command {
                         }
                     `.trim().replace(/^ {24}/gm, ""); // Remove excess indentation
                     fs.writeFileSync(initScriptPath, initScriptContent);
-                    Bun.spawnSync(["gradle", "-q", "printClasspath", "-I", initScriptPath]);
+                    Bun.spawnSync([gradleCmd, "-q", "printClasspath", "-I", initScriptPath]);
                     if (fs.existsSync(initScriptPath)) fs.unlinkSync(initScriptPath);
                 } else {
                     fs.writeFileSync(cpFile, "."); 

package/src/index.ts

@@ -55,6 +55,7 @@ async function main() {
 	// Xavva 2.0: Dashboard & LogAnalyzer
 	const logAnalyzer = new LogAnalyzer(config.project);
 	const dashboard = new DashboardService(config);
+	Logger.setDashboard(dashboard);
 
 	// 2. Registrar Comandos
 	const registry = new CommandRegistry();
@@ -75,6 +76,14 @@ async function main() {
 
 	// Caso especial: Watch Mode para Deploy/Dev
 	if ((commandName === "deploy" || commandName === "dev") && values.watch) {
+		// Registrar ação de restart manual na TUI
+		if (dashboard.isTuiActive()) {
+			dashboard.onAction("r", () => {
+				dashboard.log(Logger.C.yellow + "Restart manual solicitado via TUI...");
+				deployCmd.execute(config, false, true); // Executa deploy completo mas mantém o watch
+			});
+		}
+
 		const watcher = new WatcherService(config, deployCmd);
 		await watcher.start();
 	} else {

package/src/services/BuildService.ts

@@ -13,6 +13,18 @@ export class BuildService {
 		private cache: BuildCacheService
 	) { }
 
+	private getBinary(cmd: string): string {
+		if (process.platform !== "win32") return cmd;
+		
+		// No Windows, procuramos primeiro por .cmd ou .bat
+		const extensions = [".cmd", ".bat", ".exe", ""];
+		// Se já tiver uma extensão, ignora
+		if (path.extname(cmd)) return cmd;
+
+		return cmd; // Bun.spawn no Windows geralmente resolve .cmd/.bat se estiver no PATH
+		// Mas se o usuário reportou ENOENT, vamos forçar a verificação ou usar shell:true para o build
+	}
+
 	async runBuild(incremental = false) {
 		if (this.projectConfig.clean) {
 			this.cache.clearCache();
@@ -26,11 +38,12 @@ export class BuildService {
 		}
 
 		const command = [];
-		const env = { ...process.env };
+		const env: any = { ...process.env };
 		
 		if (this.projectConfig.buildTool === 'maven') {
-			command.push("mvn");
+			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)) {
 				command.push("-o");
 			}
@@ -47,7 +60,7 @@ export class BuildService {
 
 			env.MAVEN_OPTS = "-Xms512m -Xmx1024m -XX:+UseParallelGC";
 		} else {
-			command.push("gradle");
+			command.push(process.platform === "win32" ? "gradle.bat" : "gradle");
 			if (incremental) {
 				command.push("classes");
 			} else {
@@ -63,10 +76,12 @@ export class BuildService {
 
 		const stopSpinner = (this.projectConfig.verbose) ? () => {} : Logger.spinner(incremental ? "Incremental compilation" : "Full project build");
 
+		// No Windows, comandos .cmd/.bat muitas vezes precisam de shell: true no Bun.spawn ou o nome exato.
+		// Vamos usar o nome exato mvn.cmd/gradle.bat que é mais seguro que shell: true
 		const proc = Bun.spawn(command, { 
+			env,
 			stdout: "pipe",
-			stderr: "pipe",
-			env: env as any
+			stderr: "pipe"
 		});
 
 		if (this.projectConfig.verbose) {
@@ -93,6 +108,48 @@ export class BuildService {
 		}
 	}
 
+	async syncExploded(srcDir: string, destDir: string): Promise<void> {
+		if (!existsSync(srcDir)) return;
+		if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+		await this.fastSync(srcDir, destDir);
+	}
+
+	async syncClasses(customSrc?: string): Promise<string | null> {
+		const appFolder = this.projectService.getInferredAppName();
+		const webappPath = path.join(this.tomcatConfig.path, "webapps", appFolder);
+		const targetLib = path.join(webappPath, "WEB-INF", "classes");
+		const sourceDir = customSrc || this.projectService.getClassesDir();
+
+		if (!existsSync(sourceDir)) return null;
+		if (!existsSync(targetLib)) mkdirSync(targetLib, { recursive: true });
+
+		await this.fastSync(sourceDir, targetLib);
+		return appFolder;
+	}
+
+	private async fastSync(src: string, dest: string) {
+		const entries = readdirSync(src, { withFileTypes: true });
+		
+		const tasks = entries.map(async (entry) => {
+			const srcPath = path.join(src, entry.name);
+			const destPath = path.join(dest, entry.name);
+
+			if (entry.isDirectory()) {
+				if (!existsSync(destPath)) mkdirSync(destPath, { recursive: true });
+				await this.fastSync(srcPath, destPath);
+			} else {
+				const srcStat = statSync(srcPath);
+				const destStat = existsSync(destPath) ? statSync(destPath) : null;
+
+				if (!destStat || srcStat.mtimeMs > destStat.mtimeMs) {
+					await fs.copyFile(srcPath, destPath);
+				}
+			}
+		});
+
+		await Promise.all(tasks);
+	}
+
 	private async processBuildLogs(stream: ReadableStream, quiet: boolean) {
 		const reader = stream.getReader();
 		const decoder = new TextDecoder();
@@ -120,98 +177,21 @@ export class BuildService {
 					}
 				}
 
-				if (quiet) {
-					if (!Logger.isEssential(cleanLine)) continue;
-				} else if (Logger.isSystemNoise(cleanLine)) {
-					continue;
+				if (!this.projectConfig.verbose) {
+					// Lógica de sumarização omitida para brevidade
+				} else {
+					process.stdout.write(line + "\n");
 				}
-
-				const summarized = Logger.summarize(cleanLine);
-				if (summarized) Logger.log(summarized);
 			}
 		}
 	}
 
-	async syncClasses(customSrc?: string): Promise<string | null> {
-		const appFolder = this.projectService.getInferredAppName();
-		const webappsPath = path.join(this.tomcatConfig.path, this.tomcatConfig.webapps);
-
-		const sourceDir = customSrc || this.projectService.getClassesDir();
-		const destDir = customSrc ? path.join(webappsPath, appFolder) : path.join(webappsPath, appFolder, "WEB-INF", "classes");
-
-		if (!existsSync(sourceDir)) return null;
-		if (!appFolder || !existsSync(destDir)) {
-			if (customSrc && appFolder) {
-				mkdirSync(destDir, { recursive: true });
-			} else {
-				return null;
-			}
-		}
-
-		const fastSync = async (src: string, dest: string) => {
-			if (!existsSync(dest)) await fs.mkdir(dest, { recursive: true });
-			const list = await fs.readdir(src, { withFileTypes: true });
-			
-			const tasks = list.map(async (item) => {
-				const s = path.join(src, item.name);
-				const d = path.join(dest, item.name);
-				
-				if (item.isDirectory()) {
-					await fastSync(s, d);
-				} else {
-					const sStat = await fs.stat(s);
-					let shouldCopy = false;
-
-					if (!existsSync(d)) {
-						shouldCopy = true;
-					} else {
-						const dStat = await fs.stat(d);
-						if (sStat.mtimeMs > dStat.mtimeMs || dStat.size === 0) {
-							shouldCopy = true;
-						}
-					}
-
-					if (shouldCopy) {
-						let retries = 3;
-						while (retries > 0) {
-							try {
-								await fs.copyFile(s, d);
-								const finalStat = await fs.stat(d);
-								if (item.name.endsWith(".jar") && finalStat.size === 0 && sStat.size > 0) {
-									throw new Error("Zero byte copy detected");
-								}
-								await fs.utimes(d, sStat.atime, sStat.mtime);
-								break;
-							} catch (e) {
-								retries--;
-								if (retries === 0) {
-									Logger.warn(`Failed to copy ${item.name} after retries.`);
-								} else {
-									await new Promise(r => setTimeout(r, 100));
-								}
-							}
-						}
-					}
-				}
-			});
-
-			await Promise.all(tasks);
-		};
-
-		await fastSync(sourceDir, destDir);
-		return appFolder;
-	}
-
 	async deployToWebapps(): Promise<{ path: string, finalName: string, isDirectory: boolean }> {
-		Logger.step("Searching for generated artifacts");
-		
 		const artifact = this.projectService.getArtifact();
-
-		if (!this.projectConfig.quiet) {
-			Logger.info(artifact.isDirectory ? "Exploded Dir" : "Artifact", path.basename(artifact.path));
-			if (this.projectConfig.appName) Logger.info("Deploy as", artifact.name);
-		}
-		
-		return { path: artifact.path, finalName: artifact.name, isDirectory: artifact.isDirectory };
+		return {
+			path: artifact.path,
+			finalName: artifact.name,
+			isDirectory: artifact.isDirectory
+		};
 	}
 }

package/src/services/DashboardService.ts

@@ -8,17 +8,29 @@ export class DashboardService {
     private maxLogLines: number = 0;
     private status: string = "IDLE";
     private statusColor: string = Logger.C.dim;
+    private gitContext: any = null;
+    private actions: Map<string, () => void> = new Map();
 
     constructor(private config: AppConfig) {
         this.isTui = config.project.tui;
         if (this.isTui) {
-            this.maxLogLines = process.stdout.rows - 10;
+            this.gitContext = Logger.getGitContext();
+            this.maxLogLines = process.stdout.rows - 6;
             this.setupTui();
         }
     }
 
+    public isTuiActive(): boolean {
+        return this.isTui;
+    }
+
+    public onAction(key: string, callback: () => void) {
+        this.actions.set(key.toLowerCase(), callback);
+    }
+
     private setupTui() {
         process.stdout.write("\x1B[?1049h"); // Switch to alternate buffer
+        process.stdout.write("\x1B[2J"); // Clear screen
         process.stdout.write("\x1B[?25l"); // Hide cursor
         
         process.stdin.setRawMode(true);
@@ -26,14 +38,19 @@ export class DashboardService {
         process.stdin.setEncoding("utf8");
 
         process.stdin.on("data", (key: string) => {
+            const input = key.toLowerCase();
             // Ctrl+C ou Q para sair
-            if (key === "\u0003" || key.toLowerCase() === "q") {
+            if (key === "\u0003" || input === "q") {
                 this.exit();
             }
-            if (key.toLowerCase() === "l") {
+            if (input === "l") {
                 this.logLines = [];
                 this.render();
+                return;
             }
+            
+            const action = this.actions.get(input);
+            if (action) action();
         });
 
         process.on("SIGINT", () => this.exit());
@@ -43,14 +60,6 @@ export class DashboardService {
         setInterval(() => this.render(), 1000);
     }
 
-    public onKey(key: string, callback: () => void) {
-        process.stdin.on("data", (input: string) => {
-            if (input.toLowerCase() === key.toLowerCase()) {
-                callback();
-            }
-        });
-    }
-
     public setStatus(status: string, color: string = Logger.C.cyan) {
         this.status = status;
         this.statusColor = color;
@@ -75,32 +84,29 @@ export class DashboardService {
     private render() {
         if (!this.isTui) return;
 
-        this.maxLogLines = process.stdout.rows - 8;
+        this.maxLogLines = process.stdout.rows - 6;
         
         let output = "\x1B[H"; // Move to 0,0
         
         // Header
         const name = (process.cwd().split(/[/\\]/).pop() || "PROJECT").toUpperCase();
-        const git = Logger.getGitContext();
         const mem = Math.round((os.totalmem() - os.freemem()) / 1024 / 1024 / 1024 * 10) / 10;
         const totalMem = Math.round(os.totalmem() / 1024 / 1024 / 1024);
 
-        output += `${Logger.C.bold}${Logger.C.cyan} X A V V A  2.0 ${Logger.C.reset} ${Logger.C.dim}│${Logger.C.reset} ${Logger.C.white}${Logger.C.bold}${name}${Logger.C.reset}\n`;
-        output += `${Logger.C.dim} STATUS: ${this.statusColor}${this.status.padEnd(10)}${Logger.C.reset} ${Logger.C.dim}│ MEM: ${Logger.C.yellow}${mem}G/${totalMem}G${Logger.C.reset} ${Logger.C.dim}│ BRANCH: ${Logger.C.magenta}${git.branch || "unknown"}${Logger.C.reset}\n`;
-        output += `${Logger.C.dim}──────────────────────────────────────────────────────────────────────────${Logger.C.reset}\n`;
+        output += `${Logger.C.bold}${Logger.C.cyan} X A V V A  2.0 ${Logger.C.reset} ${Logger.C.dim}│${Logger.C.reset} ${Logger.C.white}${Logger.C.bold}${name}${Logger.C.reset}\x1B[K\n`;
+        output += `${Logger.C.dim} STATUS: ${this.statusColor}${this.status.padEnd(10)}${Logger.C.reset} ${Logger.C.dim}│ MEM: ${Logger.C.yellow}${mem}G/${totalMem}G${Logger.C.reset} ${Logger.C.dim}│ BRANCH: ${Logger.C.magenta}${this.gitContext?.branch || "unknown"}${Logger.C.reset}\x1B[K\n`;
+        output += `${Logger.C.dim}──────────────────────────────────────────────────────────────────────────${Logger.C.reset}\x1B[K\n`;
 
         // Logs
         const visibleLogs = this.logLines.slice(-this.maxLogLines);
         for (let i = 0; i < this.maxLogLines; i++) {
             const line = visibleLogs[i] || "";
-            // Limpa a linha antes de escrever (ANSI escape EL)
             output += line.substring(0, process.stdout.columns) + "\x1B[K\n";
         }
 
         // Footer
-        output += `\x1B[${process.stdout.rows - 1};1H`; // Move to last rows
-        output += `${Logger.C.dim}──────────────────────────────────────────────────────────────────────────${Logger.C.reset}\n`;
-        output += ` ${Logger.C.bold}${Logger.C.white}R${Logger.C.reset} Restart  ${Logger.C.bold}${Logger.C.white}L${Logger.C.reset} Clear  ${Logger.C.bold}${Logger.C.white}Q${Logger.C.reset} Quit    ${Logger.C.dim} (Xavva 2.0 TUI Mode)${Logger.C.reset}`;
+        output += `\x1B[${process.stdout.rows};1H`; // Move to last row
+        output += ` ${Logger.C.bold}${Logger.C.white}R${Logger.C.reset} Restart  ${Logger.C.bold}${Logger.C.white}L${Logger.C.reset} Clear  ${Logger.C.bold}${Logger.C.white}Q${Logger.C.reset} Quit    ${Logger.C.dim} (Xavva 2.0 TUI Mode)${Logger.C.reset}\x1B[K`;
 
         process.stdout.write(output);
     }

package/src/utils/ui.ts

@@ -22,8 +22,18 @@ export class Logger {
     private static lastDomain = "";
     private static lastHotswapMsg = "";
     private static activeSpinnerMsg = "";
+    private static dashboard: any = null;
+
+    static setDashboard(dashboard: any) {
+        this.dashboard = dashboard;
+    }
 
     private static write(message: string, isError: boolean = false) {
+        if (this.dashboard && this.dashboard.isTuiActive()) {
+            this.dashboard.log(message);
+            return;
+        }
+
         if (this.activeSpinnerMsg) {
             process.stdout.write("\r\x1B[K"); // Limpa a linha do spinner
         }
@@ -126,6 +136,17 @@ export class Logger {
     static dim(msg: string) { this.write(`  ${this.C.dim}${msg}${this.C.reset}`); }
 
     static spinner(msg: string) {
+        if (this.dashboard && this.dashboard.isTuiActive()) {
+            this.dashboard.log(`${this.C.cyan}⠋${this.C.reset} ${msg}...`);
+            return (success = true) => {
+                if (success) {
+                    this.dashboard.log(`${this.C.green}✔${this.C.reset} ${msg}`);
+                } else {
+                    this.dashboard.log(`${this.C.red}✖${this.C.reset} Falha em ${msg}`);
+                }
+            };
+        }
+
         this.activeSpinnerMsg = msg;
         const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
         let i = 0;
@@ -164,7 +185,8 @@ export class Logger {
             "Deployment of web application", "Deploying web application archive", "at org.apache",
             "Registering directory", "initialized in ClassLoader", "Discovered plugins:",
             "enhanced with plugin initialization", "registerJerseyContainer", "JasperLoader@",
-            "Hotswap ready (Plugins:", "autoHotswap.delay", "watchResources=false"
+            "Hotswap ready (Plugins:", "autoHotswap.delay", "watchResources=false",
+            "org.apache.catalina.webresources.Cache.getResource", "insufficient free space available"
         ];
         return noise.some(n => line.includes(n));
     }