@archznn/xavva 2.4.0 → 2.6.0

package/README.md

@@ -1,8 +1,8 @@
 # XAVVA CLI 🚀
 
-> Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows
+> Ultra-fast development toolkit for Java Enterprise (Tomcat) on Windows, Linux & macOS
 
-[![Version](https://img.shields.io/badge/version-2.4.0-blue.svg)](https://github.com/leorsousa05/Xavva)
+[![Version](https://img.shields.io/badge/version-2.6.0-blue.svg)](https://github.com/leorsousa05/Xavva)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
 Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomcat development experience. It brings modern development workflows (like Node.js/Vite) to the Java Enterprise ecosystem with hot-reload, smart logging, and automated deployment.
@@ -25,7 +25,7 @@ Xavva is a high-performance CLI built with **Bun** that transforms the Java/Tomc
 
 ## 📦 Installation
 
-```powershell
+```bash
 # Via NPM
 npm install -g @archznn/xavva
 
@@ -196,12 +196,14 @@ Create `xavva.json` in your project root:
     "tui": false
   },
   "tomcat": {
-    "path": "C:/apache-tomcat",
+    "path": "/home/user/apache-tomcat",
     "port": 8080
   }
 }
 ```
 
+> **Note:** On Windows use `"path": "C:/apache-tomcat"` format.
+
 ### CLI Options
 
 | Option                 | Description                     |
@@ -224,6 +226,25 @@ Create `xavva.json` in your project root:
 
 ---
 
+## 💻 Platform Support
+
+Xavva works on all major platforms:
+
+| Platform | Status | Notes |
+|----------|--------|-------|
+| Windows  | ✅ Full | PowerShell for system integration |
+| Linux    | ✅ Full | Bash/Zsh auto-configuration |
+| macOS    | ✅ Full | Native terminal support |
+
+### Requirements
+
+- **Bun** runtime (latest version)
+- **Java** 11 or higher (JDK)
+- **Maven** 3.6+ or **Gradle** 7+
+- **Git** (optional, for version info)
+
+---
+
 ## 🏗️ Architecture
 
 Xavva uses a modular service-oriented architecture:

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@archznn/xavva",
-	"version": "2.4.0",
-	"description": "Ultra-fast CLI tool for Java/Tomcat development on Windows with Hot-Reload and Zero Config.",
+	"version": "2.6.0",
+	"description": "Ultra-fast CLI tool for Java/Tomcat development with Hot-Reload and Zero Config. Supports Windows, Linux and macOS.",
 	"module": "src/index.ts",
 	"type": "module",
 	"bin": {
@@ -19,6 +19,8 @@
 		"gradle",
 		"hot-reload",
 		"windows",
+		"linux",
+		"macos",
 		"cli",
 		"bun"
 	],

package/src/commands/DeployCommand.ts

@@ -7,6 +7,11 @@ import { TomcatService } from "../services/TomcatService";
 import { Logger } from "../utils/ui";
 import { EndpointService } from "../services/EndpointService";
 import { BrowserService } from "../services/BrowserService";
+import {
+	getJavaPath,
+	getWarExtractCommand,
+	isWindows,
+} from "../utils/platform";
 
 export class DeployCommand implements Command {
     constructor(private tomcat: TomcatService, private builder: BuildService) {}
@@ -14,6 +19,7 @@ export class DeployCommand implements Command {
     async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
         const incremental = args?.watch && args?.incremental;
         const isWatching = !!args?.watch;
+        const changedFiles = args?.changedFiles;
         const tomcat = this.tomcat;
         const builder = this.builder;
 
@@ -46,11 +52,11 @@ export class DeployCommand implements Command {
             }
 
             if (incremental) {
-                const actualAppFolder = await builder.syncClasses(); 
+                const actualAppFolder = await builder.syncClasses(changedFiles); 
                 const actualContextPath = contextPath || actualAppFolder || "";
                 const actualAppUrl = `http://localhost:${config.tomcat.port}/${actualContextPath}`;
                 await BrowserService.reload(actualAppUrl);
-                Logger.success("redeploy completed");
+                Logger.success(`redeploy completed (${changedFiles?.length || 'all'} file(s))`);
                 return;
             }
 
@@ -77,15 +83,28 @@ export class DeployCommand implements Command {
                         Bun.spawnSync(["jar", "xf", artifactInfo.path], { cwd: appWebappPath });
                         Logger.server("extracted WAR");
                     } catch (e) {
-                        const extractCmd = `Expand-Archive -Path $env:ARTIFACT_PATH -DestinationPath $env:DEST_PATH -Force`;
-                        Bun.spawnSync(["powershell", "-command", extractCmd], {
-                            env: {
-                                ...process.env,
-                                ARTIFACT_PATH: artifactInfo.path,
-                                DEST_PATH: appWebappPath
+                        // Fallback para extração com jar (funciona em todas as plataformas)
+                        if (isWindows()) {
+                            const extractCmd = `Expand-Archive -Path $env:ARTIFACT_PATH -DestinationPath $env:DEST_PATH -Force`;
+                            Bun.spawnSync(["powershell", "-command", extractCmd], {
+                                env: {
+                                    ...process.env,
+                                    ARTIFACT_PATH: artifactInfo.path,
+                                    DEST_PATH: appWebappPath
+                                }
+                            });
+                        } else {
+                            // Linux/Mac: usa unzip ou jar
+                            try {
+                                Bun.spawnSync(["unzip", "-q", "-o", artifactInfo.path, "-d", appWebappPath]);
+                            } catch {
+                                // Fallback final para jar
+                                Bun.spawnSync(getWarExtractCommand(artifactInfo.path, appWebappPath), {
+                                    cwd: appWebappPath
+                                });
                             }
-                        });
-                        Logger.server("extracted WAR (legacy)");
+                        }
+                        Logger.server("extracted WAR (fallback)");
                     }
                 } else {
                     Logger.server("webapp up to date");
@@ -98,7 +117,7 @@ export class DeployCommand implements Command {
             const finalAppUrl = `http://localhost:${config.tomcat.port}/${finalContextPath}`;
             
             tomcat.onReady = async () => {
-                await this.handleServerReady(config, finalAppUrl, finalContextPath, tomcat, incremental);
+                await this.handleServerReady(config, finalAppUrl, finalContextPath, tomcat, !!incremental);
             };
 
             tomcat.start(config, isWatching);
@@ -116,13 +135,7 @@ export class DeployCommand implements Command {
         Logger.config("watch", isWatching);
         Logger.config("debug", config.project.debug ? `port ${config.project.debugPort}` : false);
 
-        let javaBin = "java";
-        if (process.env.JAVA_HOME) {
-            const homeBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
-            if (fs.existsSync(homeBin)) javaBin = homeBin;
-        }
-        
-        const javaVer = Bun.spawnSync([javaBin, "-version"]);
+        const javaVer = Bun.spawnSync([getJavaPath(), "-version"]);
         const output = (javaVer.stderr.toString() + javaVer.stdout.toString()).toLowerCase();
         const hasDcevm = ["dcevm", "jetbrains", "trava", "jbr"].some(v => output.includes(v));
         

package/src/commands/DoctorCommand.ts

@@ -4,6 +4,17 @@ import { Logger } from "../utils/ui";
 import fs from "fs";
 import path from "path";
 import os from "os";
+import {
+	getCatalinaScript,
+	getWhichCommand,
+	getJbrDownloadUrl,
+	getTarExtractCommand,
+	getJavaPath,
+	getJavaBinary,
+	isWindows,
+	isLinux,
+	isMacOS,
+} from "../utils/platform";
 
 export class DoctorCommand implements Command {
 	async execute(config: AppConfig, values: CLIArguments = {}): Promise<void> {
@@ -25,7 +36,7 @@ export class DoctorCommand implements Command {
 
 		if (!jvmInfo.dcevm) {
 			Logger.log(
-				`    ${Logger.C.yellow}💡 Dica: Sua JVM não suporta mudanças estruturais (novos métodos/campos).${Logger.C.reset}`,
+				`    ${Logger.C.warning}💡 Dica: Sua JVM não suporta mudanças estruturais (novos métodos/campos).${Logger.C.reset}`,
 			);
 			if (values.fix) {
 				await this.installDCEVM();
@@ -41,12 +52,12 @@ export class DoctorCommand implements Command {
 
 		if (tomcatOk) {
 			const binOk = fs.existsSync(
-				path.join(config.tomcat.path, "bin", "catalina.bat"),
+				path.join(config.tomcat.path, "bin", getCatalinaScript()),
 			);
 			this.check(
 				"Tomcat Bin",
 				binOk,
-				binOk ? "OK" : "catalina.bat não encontrado",
+				binOk ? "OK" : `${getCatalinaScript()} não encontrado`,
 			);
 		}
 
@@ -211,10 +222,7 @@ export class DoctorCommand implements Command {
 
 	private checkBinary(name: string): boolean {
 		try {
-			const proc = Bun.spawnSync([
-				process.platform === "win32" ? "where" : "which",
-				name,
-			]);
+			const proc = Bun.spawnSync(getWhichCommand(name));
 			return proc.exitCode === 0;
 		} catch {
 			return false;
@@ -224,11 +232,7 @@ export class DoctorCommand implements Command {
     private checkJVM(): { name: string, dcevm: boolean } {
         try {
             // Tentar primeiro o binário do JAVA_HOME para evitar cache do Path
-            let javaBin = "java";
-            if (process.env.JAVA_HOME) {
-                const homeBin = path.join(process.env.JAVA_HOME, "bin", "java.exe");
-                if (fs.existsSync(homeBin)) javaBin = homeBin;
-            }
+            let javaBin = getJavaPath();
 
             const proc = Bun.spawnSync([javaBin, "-version"]);
             const output = (proc.stderr.toString() + proc.stdout.toString()).toLowerCase();
@@ -251,8 +255,8 @@ export class DoctorCommand implements Command {
         Logger.section("Instalação do JetBrains Runtime (JBR 21)");
         Logger.log("Baixando JDK moderna com DCEVM nativo (JBR 21 SDK)...");
         
-        // URL para o JetBrains Runtime 21 SDK Windows x64
-        const url = "https://cache-redirector.jetbrains.com/intellij-jbr/jbrsdk-21.0.6-windows-x64-b895.97.tar.gz";
+        // URL para o JetBrains Runtime 21 SDK (multiplataforma)
+        const url = getJbrDownloadUrl("21");
         const installDir = path.join(os.homedir(), ".xavva", "jdk-dcevm");
         
         // Limpar instalação anterior se existir
@@ -272,21 +276,15 @@ 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 = `tar -xzf $env:TAR_PATH -C $env:INSTALL_DIR`;
-            Bun.spawnSync(["powershell", "-command", extractCmd], {
-                env: {
-                    ...process.env,
-                    TAR_PATH: tarPath,
-                    INSTALL_DIR: installDir
-                }
-            });
+            // Extrair .tar.gz usando comando apropriado para a plataforma
+            const extractCmd = getTarExtractCommand(tarPath, installDir);
+            Bun.spawnSync(extractCmd);
             
             fs.rmSync(tarPath);
 
-            // Busca recursiva para encontrar onde está o bin/java.exe
+            // Busca recursiva para encontrar onde está o bin/java
             const findJdkRoot = (dir: string): string | null => {
-                if (fs.existsSync(path.join(dir, "bin", "java.exe"))) return dir;
+                if (fs.existsSync(path.join(dir, "bin", getJavaBinary()))) return dir;
                 const subdirs = fs.readdirSync(dir, { withFileTypes: true })
                     .filter(d => d.isDirectory())
                     .map(d => path.join(dir, d.name));
@@ -299,55 +297,110 @@ 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 = $env:JDK_PATH;
-			                                                    $bin = $env:BIN_PATH;
-			                                                    try {
-			                                                        [Environment]::SetEnvironmentVariable('JAVA_HOME', $jdk, 'Machine');
-			                                                        $pathVar = [Environment]::GetEnvironmentVariable('Path', 'Machine');
-			                                                        $paths = $pathVar -split ';' | Where-Object { $_ -ne '' };
-			                                                        $normalizedBin = $bin.TrimEnd('\\').ToLower();
-			                                                        
-			                                                        $exists = $false;
-			                                                        foreach ($p in $paths) {
-			                                                            if ($p.TrimEnd('\\').ToLower() -eq $normalizedBin) { $exists = $true; break; }
-			                                                        }
-			                                    
-			                                                        if (-not $exists) {
-			                                                            $newPath = "$bin;" + $pathVar;
-			                                                            [Environment]::SetEnvironmentVariable('Path', $newPath, 'Machine');
-			                                                        }
-			                                                        Write-Output "OK";
-			                                                    } catch {
-			                                                        Write-Error $_.Exception.Message;
-			                                                    }
-			                                                `.replace(/\n/g, ' ');
-			                                    			                                    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")) {
-			                                        Logger.error("Falha ao configurar variáveis do SISTEMA (Acesso Negado).");
-			                                        Logger.warn("Dica: Execute o terminal como ADMINISTRADOR para permitir esta alteração.");
-			                                        Logger.info("JAVA_HOME manual", jdkPath);
-			                                    } else {
-			                                        Logger.success(`DCEVM configurado no SISTEMA com sucesso!`);
-			                                        Logger.info("JAVA_HOME", jdkPath);
-			                                    }
-			                        
-			                                    Logger.newline();
-			                                    Logger.warn("IMPORTANTE: Reinicie seu terminal (ou o VS Code) para as mudanças surtirem efeito.");
-			                                } catch (e) {
-			                        
-			            			Logger.error(`Falha na instalação: ${e.message}`);
-		}
-	}
+            
+            if (isWindows()) {
+                await this.configureWindowsEnv(jdkPath, binPath);
+            } else {
+                await this.configureUnixEnv(jdkPath, binPath);
+            }
+        } catch (e: any) {
+            Logger.error(`Falha na instalação: ${e.message}`);
+        }
+    }
+
+    private async configureWindowsEnv(jdkPath: string, binPath: string) {
+        Logger.process("Configurando variáveis de ambiente do SISTEMA...");
+
+        const setEnvCmd = `
+            $jdk = $env:JDK_PATH;
+            $bin = $env:BIN_PATH;
+            try {
+                [Environment]::SetEnvironmentVariable('JAVA_HOME', $jdk, 'Machine');
+                $pathVar = [Environment]::GetEnvironmentVariable('Path', 'Machine');
+                $paths = $pathVar -split ';' | Where-Object { $_ -ne '' };
+                $normalizedBin = $bin.TrimEnd('\\\\').ToLower();
+                
+                $exists = $false;
+                foreach ($p in $paths) {
+                    if ($p.TrimEnd('\\\\').ToLower() -eq $normalizedBin) { $exists = $true; break; }
+                }
+
+                if (-not $exists) {
+                    $newPath = "$bin;" + $pathVar;
+                    [Environment]::SetEnvironmentVariable('Path', $newPath, 'Machine');
+                }
+                Write-Output "OK";
+            } catch {
+                Write-Error $_.Exception.Message;
+            }
+        `.replace(/\n/g, ' ');
+
+        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")) {
+            Logger.error("Falha ao configurar variáveis do SISTEMA (Acesso Negado).");
+            Logger.warn("Dica: Execute o terminal como ADMINISTRADOR para permitir esta alteração.");
+            Logger.info("JAVA_HOME manual", jdkPath);
+        } else {
+            Logger.success(`DCEVM configurado no SISTEMA com sucesso!`);
+            Logger.info("JAVA_HOME", jdkPath);
+        }
+
+        Logger.newline();
+        Logger.warn("IMPORTANTE: Reinicie seu terminal (ou o VS Code) para as mudanças surtirem efeito.");
+    }
+
+    private async configureUnixEnv(jdkPath: string, binPath: string) {
+        Logger.process("Configurando variáveis de ambiente...");
+
+        const shell = process.env.SHELL || "/bin/bash";
+        let rcFile = path.join(os.homedir(), ".bashrc");
+        
+        if (shell.includes("zsh")) {
+            rcFile = path.join(os.homedir(), ".zshrc");
+        } else if (shell.includes("fish")) {
+            rcFile = path.join(os.homedir(), ".config/fish/config.fish");
+        }
+
+        // Verifica se já existe JAVA_HOME configurado
+        const exportLine = `export JAVA_HOME="${jdkPath}"`;
+        const pathLine = `export PATH="${binPath}:$PATH"`;
+
+        let rcContent = "";
+        if (fs.existsSync(rcFile)) {
+            rcContent = fs.readFileSync(rcFile, "utf8");
+        }
+
+        // Remove linhas antigas do Xavva JBR
+        const lines = rcContent.split("\n");
+        const filteredLines = lines.filter(line => 
+            !line.includes("# Xavva JBR") && 
+            !line.includes("JAVA_HOME=") &&
+            !line.includes("# Added by Xavva")
+        );
+
+        // Adiciona novas configurações
+        filteredLines.push("# Added by Xavva - JetBrains Runtime (DCEVM)");
+        filteredLines.push(exportLine);
+        filteredLines.push(pathLine);
+
+        fs.writeFileSync(rcFile, filteredLines.join("\n") + "\n");
+
+        Logger.success(`DCEVM configurado em ${rcFile}`);
+        Logger.info("JAVA_HOME", jdkPath);
+        Logger.newline();
+        Logger.warn("IMPORTANTE: Execute 'source " + rcFile + "' ou reinicie seu terminal para aplicar permanentemente.");
+        Logger.info("Dica", "Para esta sessão, o JAVA_HOME já foi configurado temporariamente.");
+        
+        // Configura JAVA_HOME temporariamente para o processo atual
+        process.env.JAVA_HOME = jdkPath;
+        process.env.PATH = `${binPath}:${process.env.PATH}`;
+    }
 }

package/src/commands/LogsCommand.ts

@@ -60,7 +60,7 @@ export class LogsCommand implements Command {
                     currentSize = newStats.size;
                 } else if (newStats.size < currentSize) {
                     currentSize = newStats.size;
-                    dashboard.log(Logger.C.yellow + "Arquivo de log foi resetado/rotacionado.");
+                    dashboard.log(Logger.C.warning + "Arquivo de log foi resetado/rotacionado.");
                 }
             }
         });

package/src/commands/RunCommand.ts

@@ -5,6 +5,14 @@ import path from "path";
 import fs from "fs";
 import { glob } from "glob";
 import readline from "readline";
+import {
+	getJavaPath,
+	getMavenCommand,
+	getGradleCommand,
+	getClasspathSeparator,
+	normalizeClasspathPath,
+	isWindows,
+} from "../utils/platform";
 
 export class RunCommand implements Command {
     async execute(config: AppConfig, args?: CLIArguments): Promise<void> {
@@ -36,7 +44,8 @@ export class RunCommand implements Command {
         const { localCp, dependencyCp } = await this.getClasspath(config);
         const pathingJar = await this.createPathingJar(dependencyCp);
         
-        const finalCp = `${localCp};${pathingJar}`;
+        const sep = getClasspathSeparator();
+        const finalCp = `${localCp}${sep}${pathingJar}`;
 
         const javaArgs = [
             "-classpath", finalCp,
@@ -60,7 +69,7 @@ export class RunCommand implements Command {
             Logger.warn(`🚀 Executando ${className}...`);
         }
 
-        const bin = process.env.JAVA_HOME ? path.join(process.env.JAVA_HOME, "bin", "java.exe") : "java";
+        const bin = getJavaPath();
         
         const proc = Bun.spawn([bin, ...javaArgs], {
             stdout: "inherit",
@@ -220,9 +229,10 @@ export class RunCommand implements Command {
         const xavvaDir = path.join(process.cwd(), ".xavva");
         const jarPath = path.join(xavvaDir, "classpath.jar");
 
-        const paths = dependencyCp.split(";").filter(p => p.trim());
+        const sep = getClasspathSeparator();
+        const paths = dependencyCp.split(sep).filter(p => p.trim());
         const relativePaths = paths.map(p => {
-            let rel = path.relative(xavvaDir, p).replace(/\\/g, "/");
+            let rel = normalizeClasspathPath(path.relative(xavvaDir, p));
             if (fs.existsSync(p) && fs.statSync(p).isDirectory() && !rel.endsWith("/")) rel += "/";
             // Robust URL encoding for Class-Path as per Java Spec
             return encodeURI(rel)
@@ -296,10 +306,9 @@ export class RunCommand implements Command {
             const stopSpinner = Logger.spinner("Generating project classpath");
             try {
                 if (config.project.buildTool === "maven") {
-                    const mvnCmd = process.platform === "win32" ? "mvn.cmd" : "mvn";
-                    Bun.spawnSync([mvnCmd, "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
+                    Bun.spawnSync([getMavenCommand(), "dependency:build-classpath", `-Dmdep.outputFile=${cpFile}`]);
                 } else if (config.project.buildTool === "gradle") {
-                    const gradleCmd = process.platform === "win32" ? "gradle.bat" : "gradle";
+                    const gradleCmd = getGradleCommand();
                     const initScriptPath = path.join(xavvaDir, "init-cp.gradle");
                     const normalizedCpFile = cpFile.replace(/\\/g, "/");
                     const initScriptContent = `
@@ -335,9 +344,10 @@ export class RunCommand implements Command {
 
         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(";");
+        // Normalize platform specific separators para o separador consistente
+        const sep = getClasspathSeparator();
+        if (path.delimiter !== sep) {
+            dependencyCp = dependencyCp.split(path.delimiter).join(sep);
         }
 
         const localFolders = [
@@ -356,7 +366,7 @@ export class RunCommand implements Command {
         const localCp = localFolders
             .map(p => path.join(process.cwd(), p))
             .filter(p => fs.existsSync(p))
-            .join(";");
+            .join(getClasspathSeparator());
 
         return { localCp, dependencyCp };
     }

package/src/index.ts

@@ -93,7 +93,7 @@ async function main() {
 		// Registrar ação de restart manual na TUI
 		if (dashboard.isTuiActive()) {
 			dashboard.onAction("r", () => {
-				dashboard.log(Logger.C.yellow + "Restart manual solicitado via TUI...");
+				dashboard.log(Logger.C.warning + "Restart manual solicitado via TUI...");
 				deployCmd.execute(config, false, true); // Executa deploy completo mas mantém o watch
 			});
 		}

package/src/services/BrowserService.ts

@@ -1,15 +1,22 @@
 import { Logger } from "../utils/ui";
+import { isWindows, getOpenBrowserArgs } from "../utils/platform";
 
 export class BrowserService {
     /**
-     * Recarrega a aba ativa do browser (Chrome ou Edge) no Windows.
+     * Recarrega a aba ativa do browser (Chrome ou Edge).
+     * Nota: No Linux/Mac, esta funcionalidade é limitada devido às restrições
+     * de automação de GUI. Recomenda-se usar extensões de Live Reload.
      */
     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));
 
+        if (!isWindows()) {
+            // No Linux/Mac, tenta notificar via Browser Sync ou similar se disponível
+            // Por enquanto, apenas loga (o usuário pode usar extensões de Live Reload)
+            return;
+        }
+
         const psCommand = `
             $shell = New-Object -ComObject WScript.Shell
             $process = Get-Process | Where-Object { $_.MainWindowTitle -match "Chrome" -or $_.MainWindowTitle -match "Edge" } | Select-Object -First 1
@@ -31,11 +38,7 @@ export class BrowserService {
      * 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]);
-        }
+        const args = getOpenBrowserArgs(url);
+        Bun.spawn(args);
     }
 }