@archznn/xavva 2.5.0 → 2.7.0

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/DeployWatcher.ts

@@ -0,0 +1,183 @@
+/**
+ * DeployWatcher - Específico para watch de deploy
+ * Usa FileWatcher genérico e adiciona lógica de deploy
+ */
+
+import { FileWatcher, type FileChangeEvent } from "./FileWatcher";
+import { DeployCommand } from "../commands/DeployCommand";
+import { Logger } from "../utils/ui";
+import type { AppConfig } from "../types/config";
+import { WATCHER_DEBOUNCE_MS, WATCHER_COOLING_MS } from "../utils/constants";
+
+export class DeployWatcher {
+    private fileWatcher: FileWatcher;
+    private isDeploying = false;
+    private pendingFullBuild = false;
+    private modifiedFiles = new Set<string>();
+    private pendingFiles = new Set<string>();
+    private hasPendingChanges = false;
+
+    constructor(
+        private config: AppConfig,
+        private deployCmd: DeployCommand
+    ) {
+        this.fileWatcher = new FileWatcher({
+            recursive: true,
+            debounceMs: WATCHER_DEBOUNCE_MS,
+            coolingMs: WATCHER_COOLING_MS,
+        });
+    }
+
+    /**
+     * Inicia o watch de deploy
+     */
+    async start(): Promise<void> {
+        // Executa deploy inicial
+        await this.run(false);
+
+        // Configura handlers
+        this.setupHandlers();
+
+        // Inicia o watcher
+        this.fileWatcher.start();
+
+        Logger.info("DeployWatcher", "Monitorando alterações...");
+    }
+
+    /**
+     * Para o watching
+     */
+    stop(): void {
+        this.fileWatcher.stop();
+    }
+
+    /**
+     * Configura handlers para diferentes tipos de arquivos
+     */
+    private setupHandlers(): void {
+        // Handler para configurações de build
+        this.fileWatcher.on(/(pom\.xml|build\.gradle|build\.gradle\.kts)$/, (event) => {
+            this.handleBuildConfigChange(event);
+        });
+
+        // Handler para arquivos Java
+        this.fileWatcher.on(/\.java$/, (event) => {
+            this.handleJavaChange(event);
+        });
+
+        // Handler para recursos estáticos (JSP, HTML, CSS, etc)
+        this.fileWatcher.on(/\.(jsp|html|css|js|xml|properties)$/, (event) => {
+            this.handleResourceChange(event);
+        });
+    }
+
+    /**
+     * Trata mudança em arquivo de configuração de build
+     */
+    private async handleBuildConfigChange(event: FileChangeEvent): Promise<void> {
+        if (!event.filename) return;
+
+        Logger.watcher(`Build configuration changed: ${event.filename}`, 'warn');
+        
+        // Limpa cache quando config muda
+        const { BuildCacheService } = await import("./BuildCacheService");
+        new BuildCacheService().clearCache();
+        
+        this.pendingFullBuild = true;
+    }
+
+    /**
+     * Trata mudança em arquivo Java
+     */
+    private handleJavaChange(event: FileChangeEvent): void {
+        if (!event.filename || this.isDeploying) {
+            if (event.filename) {
+                this.pendingFiles.add(event.filename);
+                this.hasPendingChanges = true;
+            }
+            return;
+        }
+
+        Logger.watcher(event.filename, 'watch');
+        this.modifiedFiles.add(event.filename);
+
+        // Debounce para acumular múltiplas mudanças
+        this.scheduleDeploy();
+    }
+
+    /**
+     * Trata mudança em recurso estático
+     */
+    private async handleResourceChange(event: FileChangeEvent): Promise<void> {
+        if (!event.filename) return;
+
+        Logger.watcher(event.filename, 'resource');
+        
+        try {
+            await this.deployCmd.syncResource(this.config, event.filename);
+        } catch (error) {
+            Logger.error(`Falha ao sincronizar recurso: ${event.filename}`);
+        }
+    }
+
+    /**
+     * Agenda deploy após debounce
+     */
+    private scheduleDeploy(): void {
+        // O debounce já é feito pelo FileWatcher
+        // Aqui apenas executamos o deploy
+        const filesToCompile = [...this.modifiedFiles];
+        this.modifiedFiles.clear();
+        
+        this.run(this.pendingFullBuild ? false : true, filesToCompile);
+        this.pendingFullBuild = false;
+    }
+
+    /**
+     * Executa o deploy
+     */
+    private async run(incremental = false, changedFiles?: string[]): Promise<void> {
+        if (this.isDeploying) return;
+        
+        this.isDeploying = true;
+        
+        try {
+            await this.deployCmd.execute(this.config, {
+                watch: true,
+                incremental,
+                changedFiles,
+            });
+        } catch (error) {
+            // Erro já é tratado pelo comando
+        } finally {
+            this.isDeploying = false;
+            
+            // Processa mudanças pendentes
+            if (this.hasPendingChanges) {
+                const pending = [...this.pendingFiles];
+                this.pendingFiles.clear();
+                this.hasPendingChanges = false;
+                
+                Logger.watcher(`Processing ${pending.length} pending change(s)...`, 'warn');
+                
+                setTimeout(() => {
+                    this.run(true, pending);
+                }, 100);
+            }
+        }
+    }
+
+    /**
+     * Verifica se é arquivo de recurso (não Java)
+     */
+    static isResourceFile(filename: string): boolean {
+        return /\.(jsp|html|css|js|xml|properties)$/.test(filename);
+    }
+
+    /**
+     * Verifica se é arquivo de configuração de build
+     */
+    static isBuildConfig(filename: string): boolean {
+        return /^(pom\.xml|build\.gradle|build\.gradle\.kts)$/.test(filename);
+    }
+}

package/src/services/EmbeddedTomcatService.ts

@@ -1,4 +1,5 @@
 import { Logger } from "../utils/ui";
+import { VERSIONS, getAvailableTomcatVersions, isSupportedTomcatVersion } from "../config/versions";
 import {
 	existsSync,
 	mkdirSync,
@@ -10,6 +11,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;
@@ -34,41 +46,24 @@ export class EmbeddedTomcatService {
 	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: "",
-			},
-		};
+	// Versões agora centralizadas em src/config/versions.ts
 
 	constructor(options: EmbeddedTomcatOptions) {
-		this.version = options.version || "10.1.52";
+		this.version = options.version || VERSIONS.TOMCAT.DEFAULT;
 		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];
+		// Constrói URL de download baseada na plataforma
+		const versionInfo = isSupportedTomcatVersion(this.version) ? { sha512: "" } : null;
 		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 +71,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 +94,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 +122,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 +287,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();
 			});
 
-			netstat.on("close", () => {
+			checkProcess.stderr?.on("data", (data) => {
+				output += data.toString();
+			});
+
+			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
 			});
 		});
@@ -350,7 +340,7 @@ export class EmbeddedTomcatService {
 	 * Lista versões disponíveis
 	 */
 	static getAvailableVersions(): string[] {
-		return Object.keys(EmbeddedTomcatService.VERSIONS);
+		return getAvailableTomcatVersions();
 	}
 
 	/**
@@ -382,18 +372,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 +398,7 @@ export class EmbeddedTomcatService {
 				}
 			});
 
-			ps.on("error", (err) => {
+			extractProcess.on("error", (err) => {
 				spinner(false);
 				reject(err);
 			});