@archznn/xavva 2.0.1 → 2.0.2

package/README.md

@@ -1,4 +1,4 @@
-# XAVVA 🚀 (Windows Only) `v2.0.1`
+# 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.1",
+	"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/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/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/utils/ui.ts

@@ -185,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));
     }