@archznn/xavva 1.7.0 → 1.8.1

package/src/commands/DoctorCommand.ts

@@ -63,11 +63,98 @@ export class DoctorCommand implements Command {
 		this.check("Git", gitOk, gitOk ? "Disponível" : "Não encontrado no PATH");
 
 		Logger.section("Xavva Doctor - Integridade de Arquivos");
+		await this.checkJarIntegrity(values.fix, config);
 		await this.checkBOM(values.fix);
 
 		console.log("");
 	}
 
+	private async checkJarIntegrity(fix: boolean, config: AppConfig) {
+		const searchPaths = [
+			path.join(process.cwd(), "target"),
+			path.join(process.cwd(), "build"),
+			path.join(config.tomcat.path, "webapps")
+		].filter(p => fs.existsSync(p));
+
+		const corruptedJars: string[] = [];
+		const zipEndSignature = Buffer.from([0x50, 0x4b, 0x05, 0x06]);
+
+		const scan = (dir: string) => {
+			try {
+				const list = fs.readdirSync(dir, { withFileTypes: true });
+				for (const item of list) {
+					const res = path.resolve(dir, item.name);
+					if (item.isDirectory()) {
+						if (item.name === "node_modules" || item.name === ".git") continue;
+						scan(res);
+					} else if (item.name.endsWith(".jar")) {
+						try {
+							const stats = fs.statSync(res);
+							if (stats.size < 22) {
+								corruptedJars.push(res);
+								continue;
+							}
+
+							// Lê os últimos 1024 bytes para encontrar a assinatura EOCD do ZIP
+							const readSize = Math.min(stats.size, 1024);
+							const buffer = Buffer.alloc(readSize);
+							const fd = fs.openSync(res, "r");
+							fs.readSync(fd, buffer, 0, readSize, stats.size - readSize);
+							fs.closeSync(fd);
+
+							if (!buffer.includes(zipEndSignature)) {
+								corruptedJars.push(res);
+							}
+						} catch (e) {
+							corruptedJars.push(res);
+						}
+					}
+				}
+			} catch (e) {}
+		};
+
+		for (const p of searchPaths) {
+			scan(p);
+		}
+
+		if (corruptedJars.length > 0) {
+			this.check(
+				"Integridade JAR",
+				false,
+				`${corruptedJars.length} arquivos corrompidos detectados.`,
+			);
+			if (fix) {
+				for (const file of corruptedJars) {
+					try {
+						fs.unlinkSync(file);
+						console.log(`    \x1b[32m✔\x1b[0m Removido: ${path.basename(file)}`);
+					} catch (e) {}
+				}
+				Logger.success("JARs corrompidos removidos! Eles serão reconstruídos no próximo build.");
+				
+				// Limpar cache do Tomcat
+				Logger.process("Limpando cache do Tomcat (work/temp)...");
+				const tomcatWork = path.join(config.tomcat.path, "work");
+				const tomcatTemp = path.join(config.tomcat.path, "temp");
+				[tomcatWork, tomcatTemp].forEach(p => {
+					try {
+						if (fs.existsSync(p)) {
+							fs.rmSync(p, { recursive: true, force: true });
+							fs.mkdirSync(p);
+						}
+					} catch (e) {}
+				});
+				Logger.success("Cache do Tomcat limpo com sucesso.");
+			} else {
+				Logger.warn(
+					"Use 'xavva doctor --fix' para remover os JARs corrompidos e limpar o cache.",
+				);
+			}
+		} else {
+			this.check("Integridade JAR", true, "Todos os arquivos JAR parecem íntegros.");
+		}
+	}
+
 	private async checkBOM(fix: boolean) {
 		const srcPath = path.join(process.cwd(), "src");
 		if (!fs.existsSync(srcPath)) return;
@@ -185,8 +272,14 @@ export class DoctorCommand implements Command {
             Logger.success("Download concluído. Extraindo binários...");
             
             // Usar PowerShell para extrair .tar.gz (nativo no Windows 10/11)
-            const extractCmd = `powershell -command "tar -xzf '${tarPath}' -C '${installDir}'"`;
-            Bun.spawnSync(["powershell", "-command", extractCmd]);
+            const extractCmd = `tar -xzf $env:TAR_PATH -C $env:INSTALL_DIR`;
+            Bun.spawnSync(["powershell", "-command", extractCmd], {
+                env: {
+                    ...process.env,
+                    TAR_PATH: tarPath,
+                    INSTALL_DIR: installDir
+                }
+            });
             
             fs.rmSync(tarPath);
 
@@ -204,12 +297,13 @@ export class DoctorCommand implements Command {
             };
 
             const jdkPath = findJdkRoot(installDir) || installDir;
+            const binPath = path.join(jdkPath, "bin");
 			            
 			                                    Logger.process("Configurando variáveis de ambiente do SISTEMA...");
 			                        
 			                                                const setEnvCmd = `
-			                                                    $jdk = '${jdkPath}';
-			                                                    $bin = '${path.join(jdkPath, "bin")}';
+			                                                    $jdk = $env:JDK_PATH;
+			                                                    $bin = $env:BIN_PATH;
 			                                                    try {
 			                                                        [Environment]::SetEnvironmentVariable('JAVA_HOME', $jdk, 'Machine');
 			                                                        $pathVar = [Environment]::GetEnvironmentVariable('Path', 'Machine');
@@ -230,7 +324,13 @@ export class DoctorCommand implements Command {
 			                                                        Write-Error $_.Exception.Message;
 			                                                    }
 			                                                `.replace(/\n/g, ' ');
-			                                    			                                    const result = Bun.spawnSync(["powershell", "-command", setEnvCmd]);
+			                                    			                                    const result = Bun.spawnSync(["powershell", "-command", setEnvCmd], {
+                                                                            env: {
+                                                                                ...process.env,
+                                                                                JDK_PATH: jdkPath,
+                                                                                BIN_PATH: binPath
+                                                                            }
+                                                                        });
 			                                    const output = result.stdout.toString() + result.stderr.toString();
 			                        
 			                                    if (output.includes("ACCESS_DENIED")) {

package/src/commands/HelpCommand.ts

@@ -24,7 +24,8 @@ Comandos principais:
 
 Opções:
   -w, --watch   👀 Hot Reload: monitora arquivos e redeploya automaticamente.
-  -d, --debug   🐞 Habilita debug Java (JPDA) na porta 5005.
+  -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.

package/src/commands/RunCommand.ts

@@ -1,19 +1,17 @@
 import type { Command } from "./Command";
-import type { AppConfig } from "../types/config";
+import type { AppConfig, CLIArguments } from "../types/config";
 import { Logger } from "../utils/ui";
-import { spawn } from "child_process";
 import path from "path";
 
 export class RunCommand implements Command {
-    constructor(private debug: boolean = true) {}
-
-    async execute(config: AppConfig): Promise<void> {
+    async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
+        const isDebug = args?.debug !== false; // Default to true if not specified, matching previous behavior
         let className = config.project.grep;
         
         if (!className) {
             className = await this.loadFromHistory();
             if (!className) {
-                Logger.error(`Uso: xavva ${this.debug ? "debug" : "run"} NomeDaClasse`);
+                Logger.error(`Uso: xavva ${isDebug ? "debug" : "run"} NomeDaClasse`);
                 return;
             }
         }
@@ -26,7 +24,7 @@ export class RunCommand implements Command {
 
         this.saveToHistory(className);
 
-        if (this.debug) {
+        if (isDebug) {
             Logger.section(`Interactive Debug: ${className}`);
         } else {
             Logger.section(`Running: ${className}`);
@@ -37,17 +35,17 @@ export class RunCommand implements Command {
         
         const finalCp = `${localCp};${pathingJar}`;
 
-        const args = [
+        const javaArgs = [
             "-classpath", finalCp,
         ];
 
-        if (this.debug) {
-            args.push("-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005");
+        if (isDebug) {
+            javaArgs.push("-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005");
         }
 
-        args.push(className);
+        javaArgs.push(className);
 
-        if (this.debug) {
+        if (isDebug) {
             Logger.warn(`🚀 Aguardando debugger na porta 5005 para ${className}...`);
             Logger.log(`${Logger.C.cyan}Dica:${Logger.C.reset} No VS Code ou IntelliJ, use 'Attach to Remote JVM' na porta 5005.`);
             Logger.newline();
@@ -55,19 +53,20 @@ export class RunCommand implements Command {
             Logger.warn(`🚀 Executando ${className}...`);
         }
 
-        const bin = "java";
+        const bin = process.env.JAVA_HOME ? path.join(process.env.JAVA_HOME, "bin", "java.exe") : "java";
         
-        return new Promise((resolve) => {
-            const child = spawn(bin, args, {
-                stdio: "inherit",
-                shell: true
-            });
-
-            child.on("exit", () => {
-                Logger.log(`Sessão de ${this.debug ? "debug" : "execução"} encerrada.`);
-                resolve();
-            });
+        const proc = Bun.spawn([bin, ...javaArgs], {
+            stdout: "inherit",
+            stderr: "inherit",
+            stdin: "inherit",
+            env: {
+                ...process.env,
+                JAVA_OPTS: "-Xms256m -Xmx1024m"
+            } as any
         });
+
+        await proc.exited;
+        Logger.log(`Sessão de ${isDebug ? "debug" : "execução"} encerrada.`);
     }
 
     private async discoverClass(simpleName: string): Promise<string | null> {
@@ -222,22 +221,62 @@ export class RunCommand implements Command {
         const paths = dependencyCp.split(";").filter(p => p.trim());
         const relativePaths = paths.map(p => {
             let rel = path.relative(xavvaDir, p).replace(/\\/g, "/");
-            if (fs.statSync(p).isDirectory() && !rel.endsWith("/")) rel += "/";
-            return rel;
+            if (fs.existsSync(p) && fs.statSync(p).isDirectory() && !rel.endsWith("/")) rel += "/";
+            // Robust URL encoding for Class-Path as per Java Spec
+            return encodeURI(rel)
+                .replace(/#/g, '%23')
+                .replace(/\?/g, '%3F')
+                .replace(/%5B/g, '[')
+                .replace(/%5D/g, ']');
         }).join(" ");
 
-        let wrappedCp = "";
-        const maxLen = 70;
-        for (let i = 0; i < relativePaths.length; i += maxLen) {
-            const chunk = relativePaths.substring(i, i + maxLen);
-            if (i === 0) {
-                wrappedCp += chunk;
+        const header = "Class-Path: ";
+        let manifestContent = "Manifest-Version: 1.0\r\n";
+        
+        let currentLine = header;
+        const parts = relativePaths.split(" ");
+        
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i] + (i < parts.length - 1 ? " " : "");
+            
+            // Se adicionar o próximo 'part' exceder 70 bytes (margem de segurança antes do CRLF)
+            if (Buffer.from(currentLine + part).length > 70) {
+                // Se a parte em si for muito longa, precisamos quebrá-la
+                if (Buffer.from(" " + part).length > 70) {
+                    let remainingPart = part;
+                    while (remainingPart.length > 0) {
+                        const spaceLeft = 70 - Buffer.from(currentLine).length;
+                        
+                        // Encontra quantos caracteres de 'remainingPart' cabem no espaço restante
+                        let fitCount = 0;
+                        let fitBytes = 0;
+                        for (let j = 0; j < remainingPart.length; j++) {
+                            const charBytes = Buffer.from(remainingPart[j]).length;
+                            if (fitBytes + charBytes > spaceLeft) break;
+                            fitBytes += charBytes;
+                            fitCount++;
+                        }
+
+                        if (fitCount > 0) {
+                            currentLine += remainingPart.substring(0, fitCount);
+                            remainingPart = remainingPart.substring(fitCount);
+                        }
+
+                        if (remainingPart.length > 0) {
+                            manifestContent += currentLine + "\r\n";
+                            currentLine = " ";
+                        }
+                    }
+                } else {
+                    manifestContent += currentLine + "\r\n";
+                    currentLine = " " + part;
+                }
             } else {
-                wrappedCp += "\r\n " + chunk;
+                currentLine += part;
             }
         }
+        manifestContent += currentLine + "\r\n\r\n";
 
-        const manifestContent = `Manifest-Version: 1.0\r\nClass-Path: ${wrappedCp}\r\n\r\n`;
         const manifestPath = path.join(xavvaDir, "MANIFEST.MF");
         fs.writeFileSync(manifestPath, manifestContent);
 
@@ -255,22 +294,59 @@ export class RunCommand implements Command {
         if (!fs.existsSync(cpFile)) {
             const stopSpinner = Logger.spinner("Generating project classpath");
             try {
-                if (config.project.buildTool === 'maven') {
+                if (config.project.buildTool === "maven") {
                     Bun.spawnSync(["mvn", "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
+                } else if (config.project.buildTool === "gradle") {
+                    const initScriptPath = path.join(xavvaDir, "init-cp.gradle");
+                    const normalizedCpFile = cpFile.replace(/\\/g, "/");
+                    const initScriptContent = `
+                        allprojects {
+                            afterEvaluate { project ->
+                                if (project.plugins.hasPlugin('java')) {
+                                    tasks.register('printClasspath') {
+                                        doLast {
+                                            def cp = project.sourceSets.main.runtimeClasspath.asPath
+                                            def file = new File("${normalizedCpFile}")
+                                            if (!file.exists()) {
+                                                file.text = cp
+                                            } else {
+                                                file.text = file.text + File.pathSeparator + cp
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    `.trim().replace(/^ {24}/gm, ""); // Remove excess indentation
+                    fs.writeFileSync(initScriptPath, initScriptContent);
+                    Bun.spawnSync(["gradle", "-q", "printClasspath", "-I", initScriptPath]);
+                    if (fs.existsSync(initScriptPath)) fs.unlinkSync(initScriptPath);
                 } else {
                     fs.writeFileSync(cpFile, "."); 
                 }
-            } catch (e) {}
+            } catch (e) {
+                Logger.error(`Falha ao gerar classpath: ${e}`);
+            }
             stopSpinner();
         }
 
-        const dependencyCp = fs.existsSync(cpFile) ? fs.readFileSync(cpFile, "utf8").trim() : "";
+        let dependencyCp = fs.existsSync(cpFile) ? fs.readFileSync(cpFile, "utf8").trim() : "";
         
+        // Normalize platform specific separators to semicolon for consistency
+        if (path.delimiter !== ";") {
+            dependencyCp = dependencyCp.split(path.delimiter).join(";");
+        }
+
         const localFolders = [
             "target/classes",
             "target/test-classes",
             "build/classes/java/main",
             "build/classes/java/test",
+            "build/classes/kotlin/main",
+            "build/resources/main",
+            "build/resources/test",
+            "bin/main",
+            "bin/test",
             "."
         ];
         

package/src/commands/StartCommand.ts

@@ -4,8 +4,10 @@ import { TomcatService } from "../services/TomcatService";
 import { Logger } from "../utils/ui";
 
 export class StartCommand implements Command {
+    constructor(private tomcat: TomcatService) {}
+
     async execute(config: AppConfig): Promise<void> {
-        const tomcat = new TomcatService(config.tomcat);
+        const tomcat = this.tomcat;
         
         Logger.section("Start Only");
         Logger.info("Port", config.tomcat.port);

package/src/index.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
-import { watch } from "fs";
 import { ConfigManager } from "./utils/config";
+import { CommandRegistry } from "./commands/CommandRegistry";
 import { BuildCommand } from "./commands/BuildCommand";
 import { DeployCommand } from "./commands/DeployCommand";
 import { StartCommand } from "./commands/StartCommand";
@@ -10,11 +10,17 @@ import { RunCommand } from "./commands/RunCommand";
 import { LogsCommand } from "./commands/LogsCommand";
 import { DocsCommand } from "./commands/DocsCommand";
 import { AuditCommand } from "./commands/AuditCommand";
+
+import { ProjectService } from "./services/ProjectService";
 import { TomcatService } from "./services/TomcatService";
-import { EndpointService } from "./services/EndpointService";
+import { BuildService } from "./services/BuildService";
+import { AuditService } from "./services/AuditService";
+import { WatcherService } from "./services/WatcherService";
+import { BuildCacheService } from "./services/BuildCacheService";
+
 import pkg from "../package.json";
 import { Logger } from "./utils/ui";
-import path from "path";
+import type { AppConfig, CLIArguments } from "./types/config";
 
 async function main() {
 	const { config, positionals, values } = await ConfigManager.load();
@@ -32,142 +38,45 @@ async function main() {
 	}
 
 	if (values.help) {
-		new HelpCommand().execute(config);
+		new HelpCommand().execute(config, values);
 		process.exit(0);
 	}
 
-	switch (commandName) {
-		case "build":
-			await new BuildCommand().execute(config);
-			break;
-		case "start":
-			await new StartCommand().execute(config);
-			break;
-		case "doctor":
-			await new DoctorCommand().execute(config, values);
-			break;
-		case "run":
-			await new RunCommand(false).execute(config);
-			break;
-		case "debug":
-			await new RunCommand(true).execute(config);
-			break;
-		case "logs":
-			await new LogsCommand().execute(config);
-			break;
-		case "docs":
-			await new DocsCommand().execute(config);
-			break;
-		case "audit":
-			await new AuditCommand().execute(config);
-			break;
-		case "dev":
-		case "deploy":
-			await handleDeploy(config, values);
-			break;
-		default:
-			Logger.error(`Comando desconhecido: ${commandName}`);
-			new HelpCommand().execute(config);
-			process.exit(1);
-	}
-}
+	// 1. Instanciar Serviços (Injeção de Dependência)
+	const projectService = new ProjectService(config.project);
+	const buildCacheService = new BuildCacheService();
+	const buildService = new BuildService(config.project, config.tomcat, projectService, buildCacheService);
+	const tomcatService = new TomcatService(config.tomcat);
+	tomcatService.setProjectService(projectService);
+	const auditService = new AuditService(config.tomcat);
 
-async function handleDeploy(config: any, values: any) {
-	const tomcat = new TomcatService(config.tomcat);
-	const deployCmd = new DeployCommand(tomcat);
+	// 2. Registrar Comandos
+	const registry = new CommandRegistry();
 	
-	if (values.watch) {
-		let isDeploying = false;
-
-		const run = async (incremental = false) => {
-			if (isDeploying) return;
-			isDeploying = true;
-			try {
-				await deployCmd.execute(config, incremental, true);
-			} catch (e) {
-			} finally {
-				isDeploying = false;
-			}
-		};
-
-		await run(false);
-
-		let debounceTimer: Timer;
-		const coolingFiles = new Set<string>();
-
-		watch(process.cwd(), { recursive: true }, async (event, filename) => {
-			if (!filename) return;
-
-			if (coolingFiles.has(filename)) return;
-			coolingFiles.add(filename);
-			setTimeout(() => coolingFiles.delete(filename), 500);
-
-			const isJava = filename.endsWith(".java") || filename === "pom.xml" || filename === "build.gradle";
-			const isResource = filename.endsWith(".jsp") || filename.endsWith(".html") || 
-							   filename.endsWith(".css") || filename.endsWith(".js") || 
-							   filename.endsWith(".xml") || filename.endsWith(".properties");
-			
-			const isIgnored = filename.includes("target") || 
-							  filename.includes("build") || 
-							  filename.includes("node_modules") || 
-							  filename.split(/[/\\]/).some(part => part.startsWith("."));
-
-			if (isIgnored) return;
-
-			if (isResource && !isJava) {
-				const isJsp = filename.endsWith(".jsp");
-				let jspUrl = "";
-				let isPrivate = false;
-
-				if (isJsp) {
-					const parts = filename.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("/");
-						isPrivate = relPath.startsWith("WEB-INF") || relPath.startsWith("META-INF");
-						
-						let contextPath = (config.project.appName || "").replace(".war", "");
-						if (!contextPath) {
-							const webappsPath = require("path").join(config.tomcat.path, "webapps");
-							if (require("fs").existsSync(webappsPath)) {
-								const folders = require("fs").readdirSync(webappsPath, { withFileTypes: true })
-									.filter((dirent: any) => dirent.isDirectory() && !["ROOT", "manager", "host-manager", "docs"].includes(dirent.name));
-								if (folders.length === 1) contextPath = folders[0].name;
-							}
-						}
-
-						jspUrl = `http://localhost:${config.tomcat.port}${contextPath ? "/" + contextPath : ""}/${relPath}`;
-					}
-				}
-
-				if (isJsp && isPrivate) {
-					Logger.watcher(`JSP Private (WEB-INF): ${filename}`, 'change');
-					Logger.dim(`Nota: Este arquivo não é acessível via URL direta.`);
-				} else if (isJsp && jspUrl) {
-					Logger.watcher(`JSP Updated: ${jspUrl}`, 'success');
-				} else {
-					Logger.watcher(`Resource altered: ${filename}`, 'change');
-				}
-
-				await deployCmd.syncResource(config, filename);
-				return;
-			}
-
-			if (!isJava) return;
-
-			Logger.watcher(filename, 'watch');
-			clearTimeout(debounceTimer);
-			
-			debounceTimer = setTimeout(() => {
-				run(true);
-			}, 1000);
-		});
-
+	const deployCmd = new DeployCommand(tomcatService, buildService);
+	
+	registry.register("build", new BuildCommand(buildService));
+	registry.register("start", new StartCommand(tomcatService));
+	registry.register("doctor", new DoctorCommand());
+	registry.register("run", new RunCommand());
+	registry.register("debug", new RunCommand());
+	registry.register("logs", new LogsCommand());
+	registry.register("docs", new DocsCommand());
+	registry.register("audit", new AuditCommand(auditService));
+	registry.register("deploy", deployCmd);
+	registry.register("dev", deployCmd);
+
+	// Caso especial: Watch Mode para Deploy/Dev
+	if ((commandName === "deploy" || commandName === "dev") && values.watch) {
+		const watcher = new WatcherService(config, deployCmd);
+		await watcher.start();
 	} else {
-		await deployCmd.execute(config, false, false);
+		// 3. Executar do Registro
+		// Ajusta flags baseadas no nome do comando para comandos compartilhados
+		if (commandName === "debug") values.debug = true;
+		if (commandName === "run") values.debug = false;
+		
+		await registry.execute(commandName, config, values);
 	}
 }
 

package/src/services/AuditService.ts

@@ -71,7 +71,7 @@ export class AuditService {
         const normalizedPath = jarPath.split(path.sep).join("/");
         const psCommand = `
             Add-Type -AssemblyName System.IO.Compression.FileSystem
-            $zip = [System.IO.Compression.ZipFile]::OpenRead("${normalizedPath}")
+            $zip = [System.IO.Compression.ZipFile]::OpenRead($env:JAR_PATH)
             $entry = $zip.Entries | Where-Object { $_.FullName -match "pom.properties$" } | Select-Object -First 1
             if ($entry) {
                 $stream = $entry.Open()
@@ -85,7 +85,12 @@ export class AuditService {
         `;
 
         try {
-            const proc = Bun.spawn(["powershell", "-command", psCommand]);
+            const proc = Bun.spawn(["powershell", "-command", psCommand], {
+                env: {
+                    ...process.env,
+                    JAR_PATH: normalizedPath
+                }
+            });
             const output = await new Response(proc.stdout).text();
             
             const groupId = output.match(/groupId=(.*)/)?.[1]?.trim();

package/src/services/BrowserService.ts

@@ -0,0 +1,41 @@
+import { Logger } from "../utils/ui";
+
+export class BrowserService {
+    /**
+     * Recarrega a aba ativa do browser (Chrome ou Edge) no Windows.
+     */
+    public static async reload(url: string) {
+        if (process.platform !== 'win32') return;
+        
+        // Pequeno delay para garantir que o Tomcat processou o novo contexto
+        await new Promise(r => setTimeout(r, 800));
+
+        const psCommand = `
+            $shell = New-Object -ComObject WScript.Shell
+            $process = Get-Process | Where-Object { $_.MainWindowTitle -match "Chrome" -or $_.MainWindowTitle -match "Edge" } | Select-Object -First 1
+            if ($process) {
+                $shell.AppActivate($process.Id)
+                Sleep -m 100
+                $shell.SendKeys("{F5}")
+            }
+        `;
+        
+        try {
+            Bun.spawn(["powershell", "-command", psCommand]);
+        } catch (e) {
+            Logger.warn("Não foi possível recarregar o browser automaticamente.");
+        }
+    }
+
+    /**
+     * Abre a URL no browser padrão do sistema.
+     */
+    public static open(url: string) {
+        if (process.platform === 'win32') {
+            Bun.spawn(["cmd", "/c", "start", url]);
+        } else {
+            const start = process.platform === 'darwin' ? 'open' : 'xdg-open';
+            Bun.spawn([start, url]);
+        }
+    }
+}