@archznn/xavva 1.7.0 → 1.8.1

package/src/services/TomcatService.ts

@@ -1,17 +1,24 @@
-import type { TomcatConfig } from "../types/config";
+import type { TomcatConfig, AppConfig } from "../types/config";
 import { Logger } from "../utils/ui";
+import type { Subprocess } from "bun";
+import { ProjectService } from "./ProjectService";
 
 export class TomcatService {
 	private activeConfig: TomcatConfig;
-	private currentProcess: any = null;
+	private currentProcess: Subprocess | null = null;
 	private stopStartupSpinner?: (success?: boolean) => void;
 	public onReady?: () => void;
 	private pid: number | null = null;
+	private projectService: ProjectService | null = null;
 
 	constructor(customConfig: TomcatConfig) {
 		this.activeConfig = customConfig;
 	}
 
+	setProjectService(projectService: ProjectService) {
+		this.projectService = projectService;
+	}
+
 	async getMemoryUsage(): Promise<string> {
 		if (!this.pid) return "0 MB";
 		try {
@@ -35,28 +42,45 @@ export class TomcatService {
 		}
 	}
 
-	clearWebapps(appName?: string) {
-		const fs = require("fs");
+	async clearWebapps() {
+		const fs = require("fs").promises;
+		const { existsSync } = require("fs");
 		const path = require("path");
 		const webappsPath = path.join(this.activeConfig.path, "webapps");
 		const workPath = path.join(this.activeConfig.path, "work");
 		const tempPath = path.join(this.activeConfig.path, "temp");
 
 		try {
-			[workPath, tempPath].forEach(p => {
-				if (fs.existsSync(p)) {
-					fs.rmSync(p, { recursive: true, force: true });
-					fs.mkdirSync(p);
+			const cleanDir = async (p: string) => {
+				if (existsSync(p)) {
+					await fs.rm(p, { recursive: true, force: true });
+					
+					// Resiliência para Windows: garante que o diretório foi liberado antes do mkdir
+					let retries = 10;
+					while (retries > 0 && existsSync(p)) {
+						await new Promise(r => setTimeout(r, 50));
+						retries--;
+					}
+					
+					await fs.mkdir(p, { recursive: true });
 				}
-			});
+			};
 
-			const files = fs.readdirSync(webappsPath);
-			for (const file of files) {
-				const fullPath = path.join(webappsPath, file);
-				if (file === "ROOT" || file === "manager" || file === "host-manager") continue;
-				
-				fs.rmSync(fullPath, { recursive: true, force: true });
+			const tasks: Promise<any>[] = [
+				cleanDir(workPath),
+				cleanDir(tempPath)
+			];
+
+			if (existsSync(webappsPath)) {
+				const files = await fs.readdir(webappsPath);
+				for (const file of files) {
+					if (file === "ROOT" || file === "manager" || file === "host-manager") continue;
+					const fullPath = path.join(webappsPath, file);
+					tasks.push(fs.rm(fullPath, { recursive: true, force: true }));
+				}
 			}
+
+			await Promise.all(tasks);
 		} catch (e) {
 			Logger.warn("Não foi possível limpar totalmente a pasta webapps ou cache.");
 		}
@@ -97,48 +121,7 @@ export class TomcatService {
 		}
 	}
 
-	private findAllClassPaths(buildTool: 'maven' | 'gradle'): string[] {
-		const fs = require("fs");
-		const path = require("path");
-		const results: string[] = [];
-		const root = process.cwd();
-
-		const scan = (dir: string) => {
-			try {
-				const files = fs.readdirSync(dir, { withFileTypes: true });
-				for (const file of files) {
-					if (!file.isDirectory()) continue;
-					
-					const name = file.name;
-					if (name.startsWith('.') || ['node_modules', 'out', 'bin', 'src', 'webapps', '.xavva'].includes(name)) continue;
-
-					const fullPath = path.join(dir, name);
-					
-					const isMavenClasses = buildTool === 'maven' && name === 'classes' && dir.endsWith('target');
-					const isGradleClasses = buildTool === 'gradle' && name === 'main' && dir.endsWith(path.join('classes', 'java'));
-					
-					if (isMavenClasses || isGradleClasses) {
-						results.push(fullPath.replace(/\\/g, "/"));
-					} else {
-						scan(fullPath);
-					}
-				}
-			} catch (e) {}
-		};
-
-		scan(root);
-		
-		if (results.length === 0) {
-			const defaultPath = buildTool === 'maven' 
-				? path.join(root, "target", "classes")
-				: path.join(root, "build", "classes", "java", "main");
-			results.push(defaultPath.replace(/\\/g, "/"));
-		}
-
-		return results;
-	}
-
-	async start(config: any, isWatching: boolean = false) {
+	async start(config: AppConfig, isWatching: boolean = false) {
 		const binPath = `${this.activeConfig.path}\\bin\\catalina.bat`;
 		const args = (config.project.debug || isWatching) ? ["jpda", "run"] : ["run"];
 		
@@ -181,17 +164,28 @@ export class TomcatService {
 				const xavvaDir = path.join(process.cwd(), ".xavva");
 				if (!fs.existsSync(xavvaDir)) fs.mkdirSync(xavvaDir, { recursive: true });
 				
-				const classPaths = this.findAllClassPaths(config.project.buildTool);
-				const extraClasspath = classPaths.join(",");
-
 				const propsPath = path.join(xavvaDir, "hotswap-agent.properties");
-				const propsContent = `autoHotswap=true\nautoHotswap.delay=3000\nwatchResources=false\nextraClasspath=${extraClasspath}\nLOGGER=info`;
+				const propsContent = `autoHotswap=true\nautoHotswap.delay=500\nwatchResources=false\nLOGGER=info`;
 				fs.writeFileSync(propsPath, propsContent);
 				
 				catalinaOpts.push(`-Dhotswap-agent.properties.path=${propsPath}`);
+
+				if (this.projectService) {
+					const classPaths = this.projectService.findAllClassPaths();
+					if (classPaths.length > 0) {
+						catalinaOpts.push(`-Dhotswap.extraClasspath=${classPaths.join(",")}`);
+					}
+				}
 			}
 		}
 
+		// Otimizações para JSP e Debug de JSP
+		catalinaOpts.push(
+			"-Dorg.apache.jasper.compiler.development=true",
+			"-Dorg.apache.jasper.compiler.disableSmap=false",
+			"-Dorg.apache.jasper.compiler.classdebuginfo=true"
+		);
+
 		if (config.project.skipScan) {
 			catalinaOpts.push(
 				"-Dtomcat.util.scan.StandardJarScanFilter.jarsToSkip=*.jar",
@@ -203,7 +197,7 @@ export class TomcatService {
 			);
 		}
 
-		const env: any = { 
+		const env: Record<string, string | undefined> = { 
 			...process.env, 
 			CATALINA_HOME: this.activeConfig.path,
 			CATALINA_OPTS: catalinaOpts.join(" ").trim()
@@ -215,8 +209,8 @@ export class TomcatService {
 		}
 
 		if (config.project.debug) {
-			Logger.debug("Java Debugger habilitado na porta 5005");
-			env.JPDA_ADDRESS = "5005";
+			Logger.debug(`Java Debugger habilitado na porta ${config.project.debugPort}`);
+			env.JPDA_ADDRESS = String(config.project.debugPort);
 			env.JPDA_TRANSPORT = "dt_socket";
 		}
 
@@ -227,13 +221,17 @@ export class TomcatService {
 		this.currentProcess = Bun.spawn([binPath, ...args], {
 			stdout: "pipe",
 			stderr: "pipe",
-			env: env
+			env: env as any
 		});
 
 		this.pid = this.currentProcess.pid;
 
-		this.processLogStream(this.currentProcess.stdout, config.project.cleanLogs, config.project.quiet, config.project.verbose, config.tomcat.grep);
-		this.processLogStream(this.currentProcess.stderr, config.project.cleanLogs, config.project.quiet, config.project.verbose, config.tomcat.grep);
+		if (this.currentProcess.stdout) {
+			this.processLogStream(this.currentProcess.stdout as any, config.project.cleanLogs, config.project.quiet, config.project.verbose, config.tomcat.grep || "");
+		}
+		if (this.currentProcess.stderr) {
+			this.processLogStream(this.currentProcess.stderr as any, config.project.cleanLogs, config.project.quiet, config.project.verbose, config.tomcat.grep || "");
+		}
 	}
 
 	private async processLogStream(stream: ReadableStream, clean: boolean, quiet: boolean, verbose: boolean, grep: string) {

package/src/services/WatcherService.ts

@@ -0,0 +1,78 @@
+import { watch } from "fs";
+import { Logger } from "../utils/ui";
+import { DeployCommand } from "../commands/DeployCommand";
+import type { AppConfig } from "../types/config";
+
+export class WatcherService {
+    private isDeploying = false;
+    private pendingFullBuild = false;
+    private coolingFiles = new Set<string>();
+    private debounceTimer?: Timer;
+
+    constructor(private config: AppConfig, private deployCmd: DeployCommand) {}
+
+    public async start() {
+        await this.run(false);
+
+        watch(process.cwd(), { recursive: true }, async (event, filename) => {
+            if (!filename) return;
+
+            if (this.coolingFiles.has(filename)) return;
+            this.coolingFiles.add(filename);
+            setTimeout(() => this.coolingFiles.delete(filename), 500);
+
+            if (this.isIgnored(filename)) return;
+
+            const isBuildConfig = filename === "pom.xml" || filename === "build.gradle" || filename === "build.gradle.kts";
+            const isJava = filename.endsWith(".java") || isBuildConfig;
+            const isResource = this.isResourceFile(filename);
+
+            if (isBuildConfig) {
+                Logger.watcher(`Build configuration changed: ${filename}`, 'warn');
+                const { BuildCacheService } = await import("./BuildCacheService");
+                new BuildCacheService().clearCache();
+                this.pendingFullBuild = true;
+            }
+
+            if (isResource && !isJava) {
+                await this.deployCmd.syncResource(this.config, filename);
+                return;
+            }
+
+            if (!isJava) return;
+
+            Logger.watcher(filename, 'watch');
+            clearTimeout(this.debounceTimer);
+            
+            this.debounceTimer = setTimeout(() => {
+                this.run(this.pendingFullBuild ? false : true);
+                this.pendingFullBuild = false;
+            }, 1000);
+        });
+    }
+
+    private async run(incremental = false) {
+        if (this.isDeploying) return;
+        this.isDeploying = true;
+        try {
+            await this.deployCmd.execute(this.config, { watch: true, incremental });
+        } catch (e) {
+            // Error handled by command
+        } finally {
+            this.isDeploying = false;
+        }
+    }
+
+    private isIgnored(filename: string): boolean {
+        return filename.includes("target") || 
+               filename.includes("build") || 
+               filename.includes("node_modules") || 
+               filename.split(/[/\\]/).some(part => part.startsWith("."));
+    }
+
+    private isResourceFile(filename: string): boolean {
+        return filename.endsWith(".jsp") || filename.endsWith(".html") || 
+               filename.endsWith(".css") || filename.endsWith(".js") || 
+               filename.endsWith(".xml") || filename.endsWith(".properties");
+    }
+}

package/src/types/config.ts

@@ -11,10 +11,12 @@ export interface ProjectConfig {
     profile: string;
     skipBuild: boolean;
     skipScan: boolean;
-    cleanLogs: boolean;
+    clean: boolean;
     quiet: boolean;
     verbose: boolean;
     debug: boolean;
+    debugPort: number;
+    cleanLogs: boolean;
     grep?: string;
 }
 
@@ -22,3 +24,30 @@ export interface AppConfig {
     tomcat: TomcatConfig;
     project: ProjectConfig;
 }
+
+export interface CLIArguments {
+    path?: string;
+    tool?: string;
+    name?: string;
+    port?: string;
+    "no-build"?: boolean;
+    scan?: boolean;
+    clean?: boolean;
+    quiet?: boolean;
+    help?: boolean;
+    version?: boolean;
+    debug?: boolean;
+    watch?: boolean;
+    profile?: string;
+    grep?: string;
+    verbose?: boolean;
+    dp?: string;
+    fix?: boolean;
+    incremental?: boolean;
+}
+
+export interface CommandContext {
+    config: AppConfig;
+    positionals: string[];
+    values: CLIArguments;
+}

package/src/utils/config.ts

@@ -1,10 +1,10 @@
 import { parseArgs } from "util";
 import path from "path";
 import fs from "fs";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments, CommandContext } from "../types/config";
 
 export class ConfigManager {
-    static async load(): Promise<{ config: AppConfig, positionals: string[], values: any }> {
+    static async load(): Promise<CommandContext> {
         const args = Bun.argv.slice(Bun.argv[0].endsWith("bun.exe") || Bun.argv[0].endsWith("bun") ? 2 : 1);
         
         const { values, positionals } = parseArgs({
@@ -25,12 +25,14 @@ export class ConfigManager {
                 profile: { type: "string", short: "P" },
                 grep: { type: "string", short: "G" },
                 verbose: { type: "boolean", short: "V" },
+                dp: { type: "string" },
                 fix: { type: "boolean" },
             },
             strict: false,
             allowPositionals: true,
         });
 
+        const cliValues = values as CLIArguments;
         const isDev = positionals.includes("dev");
         const isRun = positionals.includes("run") || positionals.includes("debug");
         
@@ -47,30 +49,32 @@ export class ConfigManager {
 
         const config: AppConfig = {
             tomcat: {
-                path: String(values.path || envTomcatPath),
-                port: parseInt(String(values.port || "8080")),
+                path: String(cliValues.path || envTomcatPath),
+                port: parseInt(String(cliValues.port || "8080")),
                 webapps: "webapps",
-                grep: values.grep ? String(values.grep) : "",
+                grep: cliValues.grep ? String(cliValues.grep) : "",
             },
             project: {
-                appName: values.name ? String(values.name) : "",
-                buildTool: (values.tool as "maven" | "gradle") || detectedTool,
-                profile: String(values.profile || ""),
-                skipBuild: !!values["no-build"],
-                skipScan: values.scan !== undefined ? !values.scan : true,
-                cleanLogs: !!(values.clean || isDev),
-                quiet: !!(values.quiet || isDev),
-                verbose: !!values.verbose,
-                debug: !!(values.debug || isDev || isRun),
-                grep: runClass || (values.grep ? String(values.grep) : ""),
+                appName: cliValues.name ? String(cliValues.name) : "",
+                buildTool: (cliValues.tool as "maven" | "gradle") || detectedTool,
+                profile: String(cliValues.profile || ""),
+                skipBuild: !!cliValues["no-build"],
+                skipScan: cliValues.scan !== undefined ? !cliValues.scan : true,
+                clean: !!cliValues.clean,
+                cleanLogs: cliValues.verbose ? false : true,
+                quiet: cliValues.verbose ? false : true,
+                verbose: !!cliValues.verbose,
+                debug: !!(cliValues.debug || isDev || isRun),
+                debugPort: parseInt(String(cliValues.dp || "5005")),
+                grep: runClass || (cliValues.grep ? String(cliValues.grep) : ""),
             }
         };
 
-        if (isDev) values.watch = true;
+        if (isDev) cliValues.watch = true;
 
         this.ensureGitIgnore();
 
-        return { config, positionals, values };
+        return { config, positionals, values: cliValues };
     }
 
     private static detectBuildTool(): "maven" | "gradle" {

package/src/utils/ui.ts

@@ -54,21 +54,21 @@ export class Logger {
     static banner(command?: string) {
         console.clear();
         const git = this.getGitContext();
-        const name = (process.cwd().split(/[/\\]/).pop() || "JAVA").toUpperCase();
+        const name = (process.cwd().split(/[/\\]/).pop() || "PROJECT").toUpperCase();
+        const version = `v${pkg.version}`;
         
-        const width = 62;
-        const line = "─".repeat(width);
-        
-        this.write(`${this.C.gray}╭${line}╮`);
-        this.write(`${this.C.gray}│  ${this.C.bold}${this.C.blue}${name} CLI${this.C.reset}${" ".repeat(width - name.length - 6)} ${this.C.gray}│`);
+        const mode = command?.toUpperCase() || "DEPLOY";
+        const modeColor = mode === "DEV" ? this.C.green : this.C.blue;
+        const modeIcon = mode === "DEV" ? "⚡" : "🚀";
+
+        console.log("");
+        console.log(`  ${this.C.bold}${this.C.cyan}X A V V A${this.C.reset} ${this.C.dim}─${this.C.reset} ${this.C.bold}${this.C.white}${name}${this.C.reset}`);
         
-        const info = `Version: ${pkg.version}  |  Branch: ${git.branch}  |  ${git.hash}`;
-        this.write(`${this.C.gray}│  ${this.C.dim}${info}${" ".repeat(width - info.length - 2)}${this.C.gray}│`);
+        const gitInfo = git.branch ? `${this.C.magenta}🌿 ${git.branch}${this.C.reset} ${this.C.dim}•${this.C.reset} ${this.C.yellow}${git.hash}${this.C.reset}` : "";
+        console.log(`  ${this.C.dim}📦 ${version}${gitInfo ? `  ${this.C.dim}•${this.C.reset}  ${gitInfo}` : ""}${this.C.reset}`);
         
-        const modeLine = `Mode: ${command?.toUpperCase() || "DEPLOY"}`;
-        const status = command === 'dev' ? `${this.C.green}🟢` : `${this.C.blue}🔵`;
-        this.write(`${this.C.gray}│  ${this.C.yellow}${this.C.bold}${modeLine}${" ".repeat(width - modeLine.length - 5)}${status}   ${this.C.gray}│`);
-        this.write(`${this.C.gray}╰${line}╯${this.C.reset}`);
+        console.log(`  ${modeColor}${this.C.bold}⬢ ${modeIcon} ${mode} MODE${this.C.reset}`);
+        console.log(`  ${this.C.dim}─────────────────────────────────────────────────${this.C.reset}`);
     }
 
     static section(title: string) {
@@ -162,7 +162,9 @@ export class Logger {
             "org.apache.catalina.core.StandardContext.setPath", "milliseconds",
             "org.apache.catalina.startup.HostConfig.deployWAR", "org.apache.catalina.startup.HostConfig.deployDirectory",
             "Deployment of web application", "Deploying web application archive", "at org.apache",
-            "Registering directory"
+            "Registering directory", "initialized in ClassLoader", "Discovered plugins:",
+            "enhanced with plugin initialization", "registerJerseyContainer", "JasperLoader@",
+            "Hotswap ready (Plugins:", "autoHotswap.delay", "watchResources=false"
         ];
         return noise.some(n => line.includes(n));
     }