@archznn/xavva 1.6.5 → 1.8.0

package/src/services/BuildService.ts

@@ -1,14 +1,30 @@
-import { readdirSync, copyFileSync, existsSync, statSync, mkdirSync } from "fs";
+import { readdirSync, existsSync, statSync, mkdirSync, promises as fs } from "fs";
 import path from "path";
 import type { ProjectConfig, TomcatConfig } from "../types/config";
 import { Logger } from "../utils/ui";
+import { BuildCacheService } from "./BuildCacheService";
+import { ProjectService } from "./ProjectService";
 
 export class BuildService {
-	private inferredAppName: string | null = null;
-
-	constructor(private projectConfig: ProjectConfig, private tomcatConfig: TomcatConfig) { }
+	constructor(
+		private projectConfig: ProjectConfig, 
+		private tomcatConfig: TomcatConfig,
+		private projectService: ProjectService,
+		private cache: BuildCacheService
+	) { }
 
 	async runBuild(incremental = false) {
+		if (this.projectConfig.clean) {
+			this.cache.clearCache();
+		}
+
+		if (!incremental && !this.projectConfig.skipBuild) {
+			if (!this.projectConfig.clean && !this.cache.shouldRebuild(this.projectConfig.buildTool)) {
+				Logger.success("Build cache hit! Skipping full build.");
+				return;
+			}
+		}
+
 		const command = [];
 		
 		if (this.projectConfig.buildTool === 'maven') {
@@ -16,18 +32,22 @@ export class BuildService {
 			if (incremental) {
 				command.push("compile");
 			} else {
-				command.push("clean", "package");
+				if (this.projectConfig.clean) command.push("clean");
+				command.push("compile", "war:exploded");
+				command.push("-T", "1C");
 			}
-			command.push("-DskipTests");
+			command.push("-Dmaven.test.skip=true", "-Dmaven.javadoc.skip=true");
 			if (this.projectConfig.profile) command.push(`-P${this.projectConfig.profile}`);
 		} else {
 			command.push("gradle");
 			if (incremental) {
 				command.push("classes");
 			} else {
-				command.push("clean", "build");
+				if (this.projectConfig.clean) command.push("clean");
+				command.push("war");
+				command.push("--parallel", "--build-cache");
 			}
-			command.push("-x", "test");
+			command.push("-x", "test", "-x", "javadoc");
 			if (this.projectConfig.profile) command.push(`-Pprofile=${this.projectConfig.profile}`);
 		}
 
@@ -40,8 +60,8 @@ export class BuildService {
 
 		if (this.projectConfig.verbose) {
 			await Promise.all([
-				this.processBuildLogs(proc.stdout, false),
-				this.processBuildLogs(proc.stderr, false)
+				this.processBuildLogs(proc.stdout as ReadableStream, false),
+				this.processBuildLogs(proc.stderr as ReadableStream, false)
 			]);
 		}
 
@@ -51,11 +71,15 @@ export class BuildService {
 		if (proc.exitCode !== 0) {
             if (!this.projectConfig.verbose) {
                 const err = await new Response(proc.stderr).text();
-                console.log(err);
+                Logger.log(err);
             }
             Logger.error(`${this.projectConfig.buildTool.toUpperCase()} build failed!`);
             throw new Error("Falha no build do Java!");
         }
+
+		if (!incremental) {
+			this.cache.saveCache(this.projectConfig.buildTool);
+		}
 	}
 
 	private async processBuildLogs(stream: ReadableStream, quiet: boolean) {
@@ -79,7 +103,7 @@ export class BuildService {
 					errorCount++;
 					if (errorCount > maxErrors && !this.projectConfig.verbose) {
 						if (errorCount === maxErrors + 1) {
-							console.log(`\n  ${"\x1b[31m"}... e mais erros ocultos. Use -V para ver todos.${"\x1b[0m"}`);
+							Logger.warn("... e mais erros ocultos. Use -V para ver todos.");
 						}
 						continue;
 					}
@@ -92,107 +116,91 @@ export class BuildService {
 				}
 
 				const summarized = Logger.summarize(cleanLine);
-				if (summarized) console.log(summarized);
+				if (summarized) Logger.log(summarized);
 			}
 		}
 	}
 
-	async syncClasses(): Promise<string | null> {
-		const fs = require("fs");
-		let appFolder = this.projectConfig.appName || this.inferredAppName || "";
-
+	async syncClasses(customSrc?: string): Promise<string | null> {
+		const appFolder = this.projectService.getInferredAppName();
 		const webappsPath = path.join(this.tomcatConfig.path, this.tomcatConfig.webapps);
 
-		if (!appFolder && fs.existsSync(webappsPath)) {
-			const folders = fs.readdirSync(webappsPath, { withFileTypes: true })
-				.filter((dirent: any) => dirent.isDirectory() && !["ROOT", "manager", "host-manager", "docs"].includes(dirent.name));
-			
-			if (folders.length === 1) {
-				appFolder = folders[0].name;
-			} else if (folders.length > 1) {
-				const sorted = folders.map((f: any) => ({
-					name: f.name,
-					time: fs.statSync(path.join(webappsPath, f.name)).mtimeMs
-				})).sort((a: any, b: any) => b.time - a.time);
-				appFolder = sorted[0].name;
-			}
-		}
-
-		const sourceDir = this.projectConfig.buildTool === 'maven' ? 'target/classes' : 'build/classes/java/main';
-		const destDir = path.join(webappsPath, appFolder, "WEB-INF", "classes");
+		const sourceDir = customSrc || this.projectService.getClassesDir();
+		const destDir = customSrc ? path.join(webappsPath, appFolder) : path.join(webappsPath, appFolder, "WEB-INF", "classes");
 
-		if (!fs.existsSync(sourceDir)) return null;
-		
-		if (!appFolder || !fs.existsSync(destDir)) {
-			Logger.warn("Pasta descompactada no Tomcat não encontrada. Hot Swap impossível.");
-			return null;
+		if (!existsSync(sourceDir)) return null;
+		if (!appFolder || !existsSync(destDir)) {
+			if (customSrc && appFolder) {
+				mkdirSync(destDir, { recursive: true });
+			} else {
+				return null;
+			}
 		}
 
-		const copyDir = (src: string, dest: string) => {
-			if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
-			const list = fs.readdirSync(src, { withFileTypes: true });
-			for (const item of list) {
+		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()) {
-					copyDir(s, d);
+					await fastSync(s, d);
 				} else {
-					if (!fs.existsSync(d) || fs.statSync(s).mtimeMs > fs.statSync(d).mtimeMs) {
-						fs.copyFileSync(s, d);
+					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);
 		};
 
-		copyDir(sourceDir, destDir);
-		Logger.success("Classes swapped in running Tomcat");
+		await fastSync(sourceDir, destDir);
 		return appFolder;
 	}
 
-	async deployToWebapps(): Promise<string> {
-		const destDir = path.join(this.tomcatConfig.path, this.tomcatConfig.webapps);
-		
+	async deployToWebapps(): Promise<{ path: string, finalName: string, isDirectory: boolean }> {
 		Logger.step("Searching for generated artifacts");
 		
-		const findWars = (dir: string): string[] => {
-			let results: string[] = [];
-			const list = readdirSync(dir, { withFileTypes: true });
-			for (const item of list) {
-				const res = path.resolve(dir, item.name);
-				if (item.isDirectory()) {
-					if (item.name === 'target' || item.name === 'build') {
-						results = results.concat(findWars(res));
-					} else if (!['node_modules', '.git', 'src', 'webapps', 'bin', 'conf', 'lib', 'logs', 'temp', 'work'].includes(item.name)) {
-						results = results.concat(findWars(res));
-					}
-				} else if (item.name.endsWith('.war')) {
-					results.push(res);
-				}
-			}
-			return results;
-		};
-
-		const allWars = findWars(process.cwd())
-			.map(f => ({ path: f, name: path.basename(f), time: statSync(f).mtime.getTime() }))
-			.sort((a, b) => b.time - a.time);
-
-		if (allWars.length === 0) {
-			throw new Error('Nenhum arquivo .war encontrado! Verifique se o build realmente gerou um artefato.');
-		}
-
-		const warFile = allWars[0];
-		const finalName = this.projectConfig.appName ? `${this.projectConfig.appName}.war` : warFile.name;
+		const artifact = this.projectService.getArtifact();
 
 		if (!this.projectConfig.quiet) {
-			Logger.info("Artifact", warFile.name);
-			if (this.projectConfig.appName) Logger.info("Deploy as", finalName);
-		} else {
-			const displayName = this.projectConfig.appName ? `${this.projectConfig.appName}` : warFile.name.replace(".war", "");
-			process.stdout.write(`  ${"\x1b[90m"}➜${"\x1b[0m"} Deploying ${"\x1b[1m"}${displayName}${"\x1b[0m"}...\n`);
+			Logger.info(artifact.isDirectory ? "Exploded Dir" : "Artifact", path.basename(artifact.path));
+			if (this.projectConfig.appName) Logger.info("Deploy as", artifact.name);
 		}
 		
-		copyFileSync(warFile.path, path.join(destDir, finalName));
-		this.inferredAppName = finalName.replace(".war", "");
-		return finalName;
+		return { path: artifact.path, finalName: artifact.name, isDirectory: artifact.isDirectory };
 	}
 }

package/src/services/EndpointService.ts

@@ -18,6 +18,23 @@ export class EndpointService {
                     const content = readFileSync(res, 'utf8');
                     const fileEndpoints = this.parseJavaFile(content, item.name, contextPath);
                     endpoints.push(...fileEndpoints);
+                } else if (item.name.endsWith('.jsp')) {
+                    const parts = res.split(/[/\\]/);
+                    const webappIndex = parts.indexOf("webapp");
+                    const webContentIndex = parts.indexOf("WebContent");
+                    const rootIndex = webappIndex !== -1 ? webappIndex : webContentIndex;
+                    
+                    if (rootIndex !== -1) {
+                        const relPath = "/" + parts.slice(rootIndex + 1).join("/");
+                        endpoints.push({
+                            method: "GET",
+                            path: relPath,
+                            fullPath: this.combinePaths(contextPath, relPath),
+                            className: "JSP",
+                            methodName: item.name,
+                            parameters: []
+                        });
+                    }
                 }
             }
         };
@@ -33,11 +50,9 @@ export class EndpointService {
         const endpoints: ApiEndpoint[] = [];
         const className = fileName.replace(".java", "");
 
-        // Find class-level mapping
         const classPathMatch = content.match(/@(Path|RequestMapping)\s*\(\s*["'](.*?)["']\s*\)/);
         const basePath = classPathMatch ? this.normalizePath(classPathMatch[2]) : "";
 
-        // Common mapping annotations
         const methodRegex = /@(GET|POST|PUT|DELETE|PATCH|Path|RequestMapping|GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping)\s*(\(\s*["'](.*?)["']\s*\))?\s*([\s\S]*?)\s+([a-zA-Z0-9_]+)\s*\(([\s\S]*?)\)/g;
         
         let match;
@@ -98,7 +113,6 @@ export class EndpointService {
         for (const p of individualParams) {
             const trimmed = p.trim();
             
-            // Check for annotations
             const pathParam = trimmed.match(/@PathParam\s*\(\s*["'](.*?)["']\s*\)\s*(\w+)\s+(\w+)/);
             const pathVariable = trimmed.match(/@PathVariable\s*\(\s*["'](.*?)["']\s*\)\s*(\w+)\s+(\w+)/);
             const queryParam = trimmed.match(/@QueryParam\s*\(\s*["'](.*?)["']\s*\)\s*(\w+)\s+(\w+)/);

package/src/services/ProjectService.ts

@@ -0,0 +1,126 @@
+import { existsSync, readdirSync, statSync } from "fs";
+import path from "path";
+import type { ProjectConfig } from "../types/config";
+
+export class ProjectService {
+    constructor(private config: ProjectConfig) {}
+
+    getBuildOutputDir(): string {
+        return path.join(process.cwd(), this.config.buildTool === "maven" ? "target" : "build");
+    }
+
+    getClassesDir(): string {
+        return this.config.buildTool === "maven" 
+            ? path.join(process.cwd(), "target", "classes")
+            : path.join(process.cwd(), "build", "classes", "java", "main");
+    }
+
+    getSourceDirs(): string[] {
+        return [
+            path.join(process.cwd(), "src", "main", "java"),
+            path.join(process.cwd(), "src", "main", "resources"),
+            path.join(process.cwd(), "src", "main", "webapp")
+        ].filter(d => existsSync(d));
+    }
+
+    getArtifact(): { path: string; name: string; isDirectory: boolean } {
+        const buildDir = this.getBuildOutputDir();
+        const artifacts = this.searchArtifacts(buildDir).sort((a, b) => b.time - a.time);
+
+        if (artifacts.length === 0) {
+            throw new Error(`Nenhum artefato (.war ou pasta exploded) encontrado em ${buildDir}!`);
+        }
+
+        const artifact = artifacts[0];
+        return {
+            path: artifact.path,
+            name: this.config.appName ? `${this.config.appName}.war` : artifact.name,
+            isDirectory: artifact.isDirectory
+        };
+    }
+
+    private searchArtifacts(dir: string): { path: string; name: string; time: number; isDirectory: boolean }[] {
+        let results: { path: string; name: string; time: number; isDirectory: boolean }[] = [];
+        if (!existsSync(dir)) return results;
+
+        const list = readdirSync(dir, { withFileTypes: true });
+        for (const item of list) {
+            const fullPath = path.resolve(dir, item.name);
+            
+            if (item.isDirectory()) {
+                // Se for Maven e tiver WEB-INF, é um exploded war
+                if (this.config.buildTool === 'maven' && existsSync(path.join(fullPath, "WEB-INF"))) {
+                    results.push({ 
+                        path: fullPath, 
+                        name: `${item.name}.war`, 
+                        time: statSync(fullPath).mtime.getTime(),
+                        isDirectory: true 
+                    });
+                } else if (item.name.endsWith('.war')) { // Algumas ferramentas podem gerar pastas .war
+                     results.push({ 
+                        path: fullPath, 
+                        name: item.name, 
+                        time: statSync(fullPath).mtime.getTime(),
+                        isDirectory: true 
+                    });
+                } else if (['libs', 'distributions'].includes(item.name)) { // Gradle common dirs
+                    results = results.concat(this.searchArtifacts(fullPath));
+                }
+            } else if (item.name.endsWith('.war')) {
+                results.push({ 
+                    path: fullPath, 
+                    name: item.name, 
+                    time: statSync(fullPath).mtime.getTime(),
+                    isDirectory: false 
+                });
+            }
+        }
+        return results;
+    }
+
+    getInferredAppName(): string {
+        if (this.config.appName) return this.config.appName;
+        try {
+            const artifact = this.getArtifact();
+            return artifact.name.replace(".war", "");
+        } catch (e) {
+            return "ROOT";
+        }
+    }
+
+    findAllClassPaths(): string[] {
+        const results: string[] = [];
+        const root = process.cwd();
+
+        const scan = (dir: string) => {
+            try {
+                const files = 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 = this.config.buildTool === 'maven' && name === 'classes' && dir.endsWith('target');
+                    const isGradleClasses = this.config.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) {
+            results.push(this.getClassesDir().replace(/\\/g, "/"));
+        }
+
+        return results;
+    }
+}

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,7 +42,7 @@ export class TomcatService {
 		}
 	}
 
-	clearWebapps(appName?: string) {
+	clearWebapps() {
 		const fs = require("fs");
 		const path = require("path");
 		const webappsPath = path.join(this.activeConfig.path, "webapps");
@@ -70,13 +77,99 @@ export class TomcatService {
 		}
 	}
 
-	start(cleanLogs: boolean = false, debug: boolean = false, skipScan: boolean = false, quiet: boolean = false) {
+	private async ensureHotswapAgent(): Promise<string | null> {
+		const fs = require("fs");
+		const path = require("path");
+		const os = require("os");
+		const agentDir = path.join(os.homedir(), ".xavva", "agents");
+		const agentPath = path.join(agentDir, "hotswap-agent-2.0.3.jar");
+
+		if (fs.existsSync(agentPath) && fs.statSync(agentPath).size > 1000) return agentPath;
+
+		try {
+			if (!fs.existsSync(agentDir)) fs.mkdirSync(agentDir, { recursive: true });
+			
+			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}`);
+			
+			const buffer = await response.arrayBuffer();
+			fs.writeFileSync(agentPath, Buffer.from(buffer));
+			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.");
+			return null;
+		}
+	}
+
+	async start(config: AppConfig, isWatching: boolean = false) {
 		const binPath = `${this.activeConfig.path}\\bin\\catalina.bat`;
-		const args = debug ? ["jpda", "run"] : ["run"];
+		const args = (config.project.debug || isWatching) ? ["jpda", "run"] : ["run"];
 		
 		const catalinaOpts = [process.env.CATALINA_OPTS || ""];
 		
-		if (skipScan) {
+		if (config.project.debug || isWatching) {
+			const agentPath = await this.ensureHotswapAgent();
+			if (agentPath) {
+				catalinaOpts.push(`-javaagent:${agentPath}`);
+				
+				let javaBin = "java";
+				if (process.env.JAVA_HOME) {
+					javaBin = require("path").join(process.env.JAVA_HOME, "bin", "java.exe");
+				}
+
+				const javaVer = Bun.spawnSync([javaBin, "-version"]);
+				const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
+				
+				if (output.includes("dcevm") || output.includes("jbr") || output.includes("trava")) {
+					catalinaOpts.push("-XX:+AllowEnhancedClassRedefinition");
+				}
+
+				catalinaOpts.push(
+					"--add-opens=java.base/jdk.internal.loader=ALL-UNNAMED",
+					"--add-opens=java.base/java.lang=ALL-UNNAMED",
+					"--add-opens=java.base/java.io=ALL-UNNAMED",
+					"--add-opens=java.base/java.net=ALL-UNNAMED",
+					"--add-opens=java.base/java.util=ALL-UNNAMED",
+					"--add-opens=java.base/java.util.concurrent=ALL-UNNAMED",
+					"--add-opens=java.base/java.security=ALL-UNNAMED",
+					"--add-opens=java.base/jdk.internal.reflect=ALL-UNNAMED",
+					"--add-opens=java.base/java.lang.reflect=ALL-UNNAMED",
+					"--add-opens=java.base/sun.nio.ch=ALL-UNNAMED",
+					"--add-opens=java.base/java.util.jar=ALL-UNNAMED",
+					"--add-opens=java.desktop/java.beans=ALL-UNNAMED"
+				);
+				
+				const fs = require("fs");
+				const path = require("path");
+				const xavvaDir = path.join(process.cwd(), ".xavva");
+				if (!fs.existsSync(xavvaDir)) fs.mkdirSync(xavvaDir, { recursive: true });
+				
+				const propsPath = path.join(xavvaDir, "hotswap-agent.properties");
+				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",
 				"-Dtomcat.util.scan.StandardJarScanFilter.jarsToScan=",
@@ -87,35 +180,44 @@ export class TomcatService {
 			);
 		}
 
-		const env: any = { 
+		const env: Record<string, string | undefined> = { 
 			...process.env, 
 			CATALINA_HOME: this.activeConfig.path,
 			CATALINA_OPTS: catalinaOpts.join(" ").trim()
 		};
 
-		if (debug) {
-			Logger.warn("🐞 Java Debugger habilitado na porta 5005");
-			env.JPDA_ADDRESS = "5005";
+		if (process.env.JAVA_HOME) {
+			env.JAVA_HOME = process.env.JAVA_HOME;
+			env.JRE_HOME = process.env.JAVA_HOME;
+		}
+
+		if (config.project.debug) {
+			Logger.debug(`Java Debugger habilitado na porta ${config.project.debugPort}`);
+			env.JPDA_ADDRESS = String(config.project.debugPort);
 			env.JPDA_TRANSPORT = "dt_socket";
 		}
 
-		if (cleanLogs || quiet) {
+		if ((config.project.cleanLogs || config.project.quiet) && !config.project.verbose) {
 			this.stopStartupSpinner = Logger.spinner("Starting Tomcat server");
 		}
 
 		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, cleanLogs, quiet);
-		this.processLogStream(this.currentProcess.stderr, cleanLogs, quiet);
+		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) {
+	private async processLogStream(stream: ReadableStream, clean: boolean, quiet: boolean, verbose: boolean, grep: string) {
 		const reader = stream.getReader();
 		const decoder = new TextDecoder();
 
@@ -141,6 +243,11 @@ export class TomcatService {
 					}
 				}
 
+				if (verbose) {
+					Logger.log(cleanLine);
+					continue;
+				}
+
 				if (clean) {
 					if (quiet && !Logger.isEssential(cleanLine)) {
 						if (Logger.isSystemNoise(cleanLine)) continue;
@@ -149,14 +256,14 @@ export class TomcatService {
 						continue;
 					}
 
-					if (this.activeConfig.grep && !cleanLine.toLowerCase().includes(this.activeConfig.grep.toLowerCase())) {
+					if (grep && !cleanLine.toLowerCase().includes(grep.toLowerCase())) {
 						if (!Logger.isEssential(cleanLine)) continue;
 					}
 					
 					const summarized = Logger.summarize(cleanLine);
-					console.log(summarized);
+					if (summarized) Logger.log(summarized);
 				} else {
-					console.log(cleanLine);
+					Logger.log(cleanLine);
 				}
 			}
 		}