@archznn/xavva 2.6.0 → 2.7.0

package/src/errors/XavvaError.ts

@@ -0,0 +1,273 @@
+/**
+ * Hierarquia de erros específicos do Xavva
+ * Permite tratamento granular de diferentes tipos de falhas
+ */
+
+export class XavvaError extends Error {
+    public readonly code: string;
+    public readonly exitCode: number;
+    public readonly isOperational: boolean;
+
+    constructor(
+        message: string,
+        code: string = "XAVVA_ERROR",
+        exitCode: number = 1,
+        isOperational: boolean = true
+    ) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.exitCode = exitCode;
+        this.isOperational = isOperational;
+
+        // Mantém o stack trace correto
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+
+// ===== Erros de Build =====
+export class BuildError extends XavvaError {
+    constructor(message: string, details?: string) {
+        super(
+            details ? `${message}: ${details}` : message,
+            "BUILD_ERROR",
+            3,
+            true
+        );
+    }
+}
+
+export class MavenError extends BuildError {
+    constructor(message: string, exitCode?: number) {
+        super(
+            `Maven build failed${exitCode ? ` (exit ${exitCode})` : ""}: ${message}`,
+        );
+        this.code = "MAVEN_ERROR";
+    }
+}
+
+export class GradleError extends BuildError {
+    constructor(message: string, exitCode?: number) {
+        super(
+            `Gradle build failed${exitCode ? ` (exit ${exitCode})` : ""}: ${message}`,
+        );
+        this.code = "GRADLE_ERROR";
+    }
+}
+
+// ===== Erros de Deploy =====
+export class DeployError extends XavvaError {
+    constructor(message: string, details?: string) {
+        super(
+            details ? `${message}: ${details}` : message,
+            "DEPLOY_ERROR",
+            4,
+            true
+        );
+    }
+}
+
+export class ArtifactNotFoundError extends DeployError {
+    constructor(buildDir: string) {
+        super(
+            `Nenhum artefato (.war ou pasta exploded) encontrado em ${buildDir}`,
+            "Certifique-se de que o build foi executado com sucesso"
+        );
+        this.code = "ARTIFACT_NOT_FOUND";
+    }
+}
+
+// ===== Erros de Tomcat =====
+export class TomcatError extends XavvaError {
+    constructor(message: string, details?: string) {
+        super(
+            details ? `${message}: ${details}` : message,
+            "TOMCAT_ERROR",
+            5,
+            true
+        );
+    }
+}
+
+export class TomcatNotFoundError extends TomcatError {
+    constructor(path: string) {
+        super(
+            `Tomcat não encontrado em ${path}`,
+            "Defina TOMCAT_HOME, CATALINA_HOME ou use --path"
+        );
+        this.code = "TOMCAT_NOT_FOUND";
+    }
+}
+
+export class PortInUseError extends TomcatError {
+    constructor(port: number) {
+        super(
+            `Porta ${port} já está em uso`,
+            "Pare o processo que está usando a porta ou especifique outra com --port"
+        );
+        this.code = "PORT_IN_USE";
+    }
+}
+
+export class EmbeddedTomcatError extends TomcatError {
+    constructor(message: string) {
+        super(
+            `Falha no Tomcat embutido: ${message}`,
+            "Tente instalar manualmente ou use outra versão com --tomcat-version"
+        );
+        this.code = "EMBEDDED_TOMCAT_ERROR";
+    }
+}
+
+// ===== Erros de Configuração =====
+export class ConfigError extends XavvaError {
+    constructor(message: string, details?: string) {
+        super(
+            details ? `${message}: ${details}` : message,
+            "CONFIG_ERROR",
+            2,
+            true
+        );
+    }
+}
+
+export class InvalidConfigError extends ConfigError {
+    constructor(field: string, value: string, expected?: string) {
+        super(
+            `Configuração inválida: ${field} = '${value}'`,
+            expected || "Verifique sua configuração"
+        );
+        this.code = "INVALID_CONFIG";
+    }
+}
+
+export class MissingConfigError extends ConfigError {
+    constructor(field: string) {
+        super(
+            `Configuração obrigatória ausente: ${field}`,
+            `Defina ${field} no xavva.json ou via linha de comando`
+        );
+        this.code = "MISSING_CONFIG";
+    }
+}
+
+// ===== Erros de Projeto =====
+export class ProjectError extends XavvaError {
+    constructor(message: string, details?: string) {
+        super(
+            details ? `${message}: ${details}` : message,
+            "PROJECT_ERROR",
+            6,
+            true
+        );
+    }
+}
+
+export class BuildToolNotFoundError extends ProjectError {
+    constructor() {
+        super(
+            "Não foi possível detectar a ferramenta de build",
+            "Certifique-se de estar no diretório raiz do projeto (pom.xml ou build.gradle)"
+        );
+        this.code = "BUILD_TOOL_NOT_FOUND";
+    }
+}
+
+export class JavaNotFoundError extends ProjectError {
+    constructor() {
+        super(
+            "Java não encontrado",
+            "Defina JAVA_HOME ou certifique-se de que 'java' está no PATH"
+        );
+        this.code = "JAVA_NOT_FOUND";
+    }
+}
+
+// ===== Erros de Audit/Security =====
+export class AuditError extends XavvaError {
+    constructor(message: string) {
+        super(
+            `Erro na auditoria: ${message}`,
+            "AUDIT_ERROR",
+            7,
+            true
+        );
+    }
+}
+
+export class NetworkError extends XavvaError {
+    public readonly url: string;
+    public readonly originalError?: Error;
+    
+    constructor(url: string, originalError?: Error) {
+        super(
+            `Falha na conexão com ${url}${originalError ? `: ${originalError.message}` : ""}`,
+            "NETWORK_ERROR",
+            8,
+            true
+        );
+        this.url = url;
+        this.originalError = originalError;
+    }
+}
+
+// ===== Erros de File System =====
+export class FileSystemError extends XavvaError {
+    constructor(message: string, path?: string) {
+        super(
+            path ? `${message}: ${path}` : message,
+            "FILESYSTEM_ERROR",
+            9,
+            true
+        );
+    }
+}
+
+export class FileNotFoundError extends FileSystemError {
+    constructor(path: string) {
+        super("Arquivo não encontrado", path);
+        this.code = "FILE_NOT_FOUND";
+    }
+}
+
+export class PermissionError extends FileSystemError {
+    constructor(path: string) {
+        super("Permissão negada", path);
+        this.code = "PERMISSION_DENIED";
+    }
+}
+
+// ===== Erros de Comando =====
+export class CommandError extends XavvaError {
+    constructor(command: string, message: string) {
+        super(
+            `Erro no comando '${command}': ${message}`,
+            "COMMAND_ERROR",
+            10,
+            true
+        );
+    }
+}
+
+export class UnknownCommandError extends CommandError {
+    constructor(command: string) {
+        super(command, "Comando desconhecido");
+        this.code = "UNKNOWN_COMMAND";
+    }
+}
+
+// Helper para identificar se é erro operacional (vs programação)
+export function isOperationalError(error: Error): boolean {
+    if (error instanceof XavvaError) {
+        return error.isOperational;
+    }
+    return false;
+}
+
+// Helper para obter exit code de qualquer erro
+export function getExitCode(error: Error): number {
+    if (error instanceof XavvaError) {
+        return error.exitCode;
+    }
+    return 1; // Erro genérico
+}

package/src/index.ts

@@ -1,115 +1,117 @@
 #!/usr/bin/env bun
 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";
-import { HelpCommand } from "./commands/HelpCommand";
-import { DoctorCommand } from "./commands/DoctorCommand";
-import { RunCommand } from "./commands/RunCommand";
-import { LogsCommand } from "./commands/LogsCommand";
-import { DocsCommand } from "./commands/DocsCommand";
-import { AuditCommand } from "./commands/AuditCommand";
-import { ProfilesCommand } from "./commands/ProfilesCommand";
-import { DepsCommand } from "./commands/DepsCommand";
-import { TomcatCommand } from "./commands/TomcatCommand";
-
-import { ProjectService } from "./services/ProjectService";
-import { TomcatService } from "./services/TomcatService";
-import { BuildService } from "./services/BuildService";
-import { AuditService } from "./services/AuditService";
-import { WatcherService } from "./services/WatcherService";
-import { BuildCacheService } from "./services/BuildCacheService";
-import { DashboardService } from "./services/DashboardService";
-import { LogAnalyzer } from "./services/LogAnalyzer";
-
+import { createContainer, type DIContainer } from "./di/container";
+import { DeployWatcher } from "./services/DeployWatcher";
+import { ErrorHandler } from "./errors/ErrorHandler";
+import { ProcessManager } from "./utils/processManager";
 import pkg from "../package.json";
 import { Logger } from "./utils/ui";
-import { ProcessManager } from "./utils/processManager";
-import type { AppConfig, CLIArguments } from "./types/config";
+import type { CLIArguments } from "./types/args";
 
 async function main() {
-	const processManager = ProcessManager.getInstance();
-	const { config, positionals, values } = await ConfigManager.load();
+    const processManager = ProcessManager.getInstance();
+    const { config, positionals, values } = await ConfigManager.load();
+
+    // Handler de versão
+    if (values.version) {
+        Logger.log(`v${pkg.version}`);
+        await processManager.shutdown(0);
+    }
+
+    // Identifica comando
+    const commandNames = [
+        "deploy", "build", "start", "dev", "doctor", "run", 
+        "debug", "logs", "docs", "audit", "profiles", 
+        "deps", "tomcat", "encoding"
+    ];
+    const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
 
-	if (values.version) {
-		Logger.log(`v${pkg.version}`);
-		await processManager.shutdown(0);
-	}
+    // Mostra banner (exceto em help ou TUI)
+    if (!values.help && !values.tui) {
+        Logger.banner(commandName, config.project.profile, config.project.encoding);
+        if (config.project.encoding) {
+            Logger.config("Encoding", config.project.encoding);
+        }
+        if (config.tomcat.embedded) {
+            Logger.config("Tomcat", `Embutido ${config.tomcat.version}`);
+        }
+    }
 
-	const commandNames = ["deploy", "build", "start", "dev", "doctor", "run", "debug", "logs", "docs", "audit", "profiles", "deps", "tomcat"];
-	const commandName = positionals.find(p => commandNames.includes(p)) || "deploy";
+    // Handler de help
+    if (values.help) {
+        const { HelpCommand } = await import("./commands/HelpCommand");
+        new HelpCommand().execute(config, values as CLIArguments);
+        await processManager.shutdown(0);
+    }
 
-	if (!values.help && !values.tui) {
-		Logger.banner(commandName, config.project.profile, config.project.encoding);
-		if (config.project.encoding) {
-			Logger.config("Encoding", config.project.encoding);
-		}
-		if (config.tomcat.embedded) {
-			Logger.config("Tomcat", `Embutido ${config.tomcat.version}`);
-		}
-	}
+    // Inicializa Container de DI
+    let container: DIContainer;
+    try {
+        container = createContainer(config);
+        container.initialize();
+    } catch (error) {
+        await ErrorHandler.getInstance().handle(error, { phase: "di-initialization" });
+        return;
+    }
 
-	if (values.help) {
-		new HelpCommand().execute(config, values);
-		await processManager.shutdown(0);
-	}
+    const services = container.getAllServices();
+    const commands = container.getAllCommands();
 
-	// 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);
-	
-	// Xavva 2.0: Dashboard & LogAnalyzer
-	const logAnalyzer = new LogAnalyzer(config.project);
-	const dashboard = new DashboardService(config);
-	Logger.setDashboard(dashboard);
+    // Configura ações da TUI
+    if (values.tui) {
+        const deployCmd = commands.deploy;
+        services.dashboardService.onAction("r", () => {
+            services.dashboardService.log(Logger.C.warning + "Restart manual solicitado via TUI...");
+            deployCmd.execute(config, { watch: true, incremental: false });
+        });
+    }
 
-	// 2. Registrar Comandos
-	const registry = new CommandRegistry();
-	
-	const deployCmd = new DeployCommand(tomcatService, buildService);
-	const logsCmd = new LogsCommand(dashboard, logAnalyzer);
-	
-	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", logsCmd);
-	registry.register("docs", new DocsCommand());
-	registry.register("audit", new AuditCommand(auditService));
-	registry.register("profiles", new ProfilesCommand(projectService));
-	registry.register("deps", new DepsCommand());
-	registry.register("tomcat", new TomcatCommand());
-	registry.register("deploy", deployCmd);
-	registry.register("dev", deployCmd);
+    // Caso especial: Watch Mode para Deploy/Dev
+    if ((commandName === "deploy" || commandName === "dev") && values.watch) {
+        const deployCmd = commands.deploy;
+        const watcher = new DeployWatcher(config, deployCmd);
+        
+        try {
+            await watcher.start();
+        } catch (error) {
+            await ErrorHandler.getInstance().handle(error, { phase: "watch-mode", command: commandName });
+        }
+    } else {
+        // Executa comando do Registry
+        const registry = new CommandRegistry();
+        
+        // Registra todos os comandos
+        registry.register("build", commands.build);
+        registry.register("start", commands.start);
+        registry.register("doctor", commands.doctor);
+        registry.register("run", commands.run);
+        registry.register("debug", commands.debug);
+        registry.register("logs", commands.logs);
+        registry.register("docs", commands.docs);
+        registry.register("audit", commands.audit);
+        registry.register("profiles", commands.profiles);
+        registry.register("deps", commands.deps);
+        registry.register("tomcat", commands.tomcat);
+        registry.register("encoding", commands.encoding);
+        registry.register("deploy", commands.deploy);
+        registry.register("dev", commands.dev);
 
-	// Caso especial: Watch Mode para Deploy/Dev
-	if ((commandName === "deploy" || commandName === "dev") && values.watch) {
-		// Registrar ação de restart manual na TUI
-		if (dashboard.isTuiActive()) {
-			dashboard.onAction("r", () => {
-				dashboard.log(Logger.C.warning + "Restart manual solicitado via TUI...");
-				deployCmd.execute(config, false, true); // Executa deploy completo mas mantém o watch
-			});
-		}
+        // Configura flags específicas
+        if (commandName === "debug") values.debug = true;
+        if (commandName === "run") values.debug = false;
 
-		const watcher = new WatcherService(config, deployCmd);
-		await watcher.start();
-	} else {
-		// 3. Executar do Registro
-		if (commandName === "debug") values.debug = true;
-		if (commandName === "run") values.debug = false;
-		
-		await registry.execute(commandName, config, values, positionals);
-	}
+        try {
+            await registry.execute(commandName, config, values as CLIArguments, positionals);
+        } catch (error) {
+            await ErrorHandler.getInstance().handle(error, { phase: "command-execution", command: commandName });
+        }
+    }
 }
 
+// Entry point com tratamento global de erros
 main().catch(async (error) => {
-	console.error(error);
-	await ProcessManager.getInstance().shutdown(1);
+    // Erro não tratado - possível bug
+    console.error("Erro fatal não tratado:", error);
+    await ProcessManager.getInstance().shutdown(1);
 });

package/src/services/AuditService.ts

@@ -1,7 +1,8 @@
 import fs from "fs";
 import path from "path";
-import type { TomcatConfig } from "../types/config";
+import type { TomcatConfig } from "../types";
 import { Logger } from "../utils/ui";
+import { AuditError } from "../errors/XavvaError";
 
 export interface Vulnerability {
     id: string;
@@ -125,7 +126,7 @@ export class AuditService {
 
             return { groupId, artifactId, version };
         } catch (e) {
-            return {};
+            throw new AuditError(`Falha ao extrair informações do JAR: ${(e as Error).message}`);
         }
     }
 

package/src/services/BrowserService.ts

@@ -2,30 +2,83 @@ import { Logger } from "../utils/ui";
 import { isWindows, getOpenBrowserArgs } from "../utils/platform";
 
 export class BrowserService {
+    private static debugPort = 9222;
+
     /**
-     * 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.
+     * Recarrega a aba do browser que corresponde à URL da aplicação.
+     * Usa o Chrome DevTools Protocol (CDP) para encontrar e recarregar a aba correta.
+     * Nota: No Linux/Mac, esta funcionalidade é limitada.
      */
     public static async reload(url: string) {
         // 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;
         }
 
+        // Usar heredoc para evitar problemas de escaping
         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}")
-            }
-        `;
+$ErrorActionPreference = 'SilentlyContinue'
+$debugPort = ${this.debugPort}
+
+function Reload-TabByUrl {
+    param($targetUrl, $port)
+    
+    try {
+        $pages = Invoke-RestMethod -Uri "http://localhost:$port/json/list" -TimeoutSec 2
+        $targetUri = [System.Uri]$targetUrl
+        $targetPath = $targetUri.AbsolutePath.TrimEnd('/')
+        
+        foreach ($page in $pages) {
+            if ($page.type -ne "page") { continue }
+            
+            try {
+                $pageUri = [System.Uri]$page.url
+                if ($pageUri.Host -eq $targetUri.Host -and 
+                    $pageUri.AbsolutePath.TrimEnd('/') -eq $targetPath) {
+                    
+                    $body = @{ id = 1; method = "Page.reload"; params = @{ ignoreCache = $false } } | ConvertTo-Json -Compress
+                    Invoke-RestMethod -Uri "http://localhost:$port/json/reload/$($page.id)" -Method Put -Body $body -ContentType "application/json" -TimeoutSec 2 | Out-Null
+                    return $true
+                }
+            } catch { continue }
+        }
+    } catch { }
+    return $false
+}
+
+$reloaded = Reload-TabByUrl -targetUrl "${url}" -port $debugPort
+
+if (-not $reloaded) {
+    $shell = New-Object -ComObject WScript.Shell
+    $urlObj = [System.Uri]"${url}"
+    $context = $urlObj.AbsolutePath.Trim('/').Split('/')[0]
+    
+    $processes = Get-Process | Where-Object { 
+        ($_.Name -eq "chrome" -or $_.Name -eq "msedge") -and 
+        $_.MainWindowTitle -and
+        ($_.MainWindowTitle -match $context -or $_.MainWindowTitle -match "localhost")
+    }
+    
+    if ($processes) {
+        $targetProcess = $processes | Select-Object -First 1
+        $shell.AppActivate($targetProcess.Id)
+        Start-Sleep -Milliseconds 100
+        $shell.SendKeys("{F5}")
+    } else {
+        $anyBrowser = Get-Process | Where-Object { 
+            $_.Name -eq "chrome" -or $_.Name -eq "msedge" 
+        } | Select-Object -First 1
+        
+        if ($anyBrowser) {
+            $shell.AppActivate($anyBrowser.Id)
+            Start-Sleep -Milliseconds 100
+            $shell.SendKeys("{F5}")
+        }
+    }
+}
+`;
         
         try {
             Bun.spawn(["powershell", "-command", psCommand]);
@@ -35,10 +88,68 @@ export class BrowserService {
     }
 
     /**
-     * Abre a URL no browser padrão do sistema.
+     * Abre a URL no browser com remote debugging habilitado (se possível).
+     * Isso permite recarregar a aba específica posteriormente via CDP.
      */
     public static open(url: string) {
-        const args = getOpenBrowserArgs(url);
-        Bun.spawn(args);
+        if (!isWindows()) {
+            const args = getOpenBrowserArgs(url);
+            Bun.spawn(args);
+            return;
+        }
+
+        const psCommand = `
+$ErrorActionPreference = 'SilentlyContinue'
+$debugPort = ${this.debugPort}
+$targetUrl = "${url}"
+
+$debuggingEnabled = $false
+try {
+    $resp = Invoke-RestMethod -Uri "http://localhost:$debugPort/json/version" -TimeoutSec 1
+    $debuggingEnabled = $true
+} catch { }
+
+# Encontra o executável do Chrome ou Edge
+$browserExe = $null
+$chromePaths = @(
+    ("$env:ProgramFiles" + "\\Google\\Chrome\\Application\\chrome.exe"),
+    ("$env:LOCALAPPDATA" + "\\Google\\Chrome\\Application\\chrome.exe")
+)
+$edgePaths = @(
+    ("$env:ProgramFiles" + "\\Microsoft\\Edge\\Application\\msedge.exe")
+)
+
+foreach ($path in $chromePaths) {
+    if (Test-Path $path) { $browserExe = $path; break }
+}
+if (-not $browserExe) {
+    foreach ($path in $edgePaths) {
+        if (Test-Path $path) { $browserExe = $path; break }
+    }
+}
+
+if ($browserExe) {
+    if ($debuggingEnabled) {
+        try {
+            $body = @{ url = $targetUrl } | ConvertTo-Json -Compress
+            Invoke-RestMethod -Uri "http://localhost:$debugPort/json/new" -Method Put -Body $body -ContentType "application/json" -TimeoutSec 3 | Out-Null
+        } catch {
+            Start-Process $browserExe -ArgumentList $targetUrl
+        }
+    } else {
+        Start-Process $browserExe -ArgumentList $targetUrl, "--remote-debugging-port=$debugPort", "--no-first-run"
+    }
+} else {
+    Start-Process $targetUrl
+}
+`;
+        
+        try {
+            Bun.spawn(["powershell", "-command", psCommand]);
+        } catch (e) {
+            // Fallback para método padrão
+            const args = getOpenBrowserArgs(url);
+            Bun.spawn(args);
+        }
     }
 }