@archznn/xavva 3.1.2 → 3.2.0

package/src/commands/TomcatCommand.ts

@@ -1,19 +1,62 @@
 import type { Command } from "./Command";
 import type { AppConfig, CLIArguments } from "../types/config";
-import { EmbeddedTomcatService } from "../services/EmbeddedTomcatService";
-import { Logger } from "../utils/ui";
+import { Logger, C } from "../utils/ui";
+// TomcatManagerService será implementado em fase futura
+import { TomcatInstallerService } from "../services/tomcat";
 import path from "path";
 import fs from "fs";
 
 export class TomcatCommand implements Command {
+    private installer = new TomcatInstallerService();
+
+    private showHelp(): void {
+        Logger.section("Tomcat Command");
+        Logger.log(`${C.bold}Usage:${C.reset} xavva tomcat <action> [options]`);
+        Logger.newline();
+        Logger.log(`${C.bold}Actions:${C.reset}`);
+        Logger.log(`  ${C.primary}list${C.reset}         List available Tomcat versions`);
+        Logger.log(`  ${C.primary}installed${C.reset}    List installed versions`);
+        Logger.log(`  ${C.primary}install${C.reset}      Install a version`);
+        Logger.log(`  ${C.primary}use${C.reset}          Set version for this project`);
+        Logger.log(`  ${C.primary}uninstall${C.reset}    Remove a version`);
+        Logger.log(`  ${C.primary}status${C.reset}       Show current configuration`);
+        Logger.log(`  ${C.primary}backup${C.reset}       Manage backups`);
+        Logger.log(`  ${C.primary}cache${C.reset}        Manage download cache`);
+        Logger.log(`  ${C.primary}mirrors${C.reset}      Test and select mirrors`);
+        Logger.newline();
+        Logger.log(`${C.bold}Install Options:${C.reset}`);
+        Logger.log(`  ${C.primary}--mirror${C.reset} <name>      Use specific mirror (or 'auto')`);
+        Logger.log(`  ${C.primary}--no-checksum${C.reset}      Skip checksum verification`);
+        Logger.log(`  ${C.primary}--no-cache${C.reset}         Don't use download cache`);
+        Logger.log(`  ${C.primary}--no-backup${C.reset}        Skip backup if exists`);
+        Logger.log(`  ${C.primary}--silent${C.reset}           Silent mode (CI/CD)`);
+        Logger.log(`  ${C.primary}--timeout${C.reset} <sec>    Download timeout (default: 300)`);
+        Logger.log(`  ${C.primary}--retries${C.reset} <n>      Retry attempts (default: 3)`);
+        Logger.log(`  ${C.primary}--force${C.reset}            Force reinstallation`);
+        Logger.log(`  ${C.primary}--parallel${C.reset}         Install multiple versions`);
+        Logger.newline();
+        Logger.log(`${C.bold}Examples:${C.reset}`);
+        Logger.log(`  xavva tomcat list`);
+        Logger.log(`  xavva tomcat install 10.1.52`);
+        Logger.log(`  xavva tomcat install 9.0.115 --mirror auto`);
+        Logger.log(`  xavva tomcat install 10.1.52 9.0.115 --parallel`);
+        Logger.log(`  xavva tomcat use 10.1.52`);
+        Logger.log(`  xavva tomcat backup list`);
+        Logger.log(`  xavva tomcat cache stats`);
+        Logger.log(`  xavva tomcat mirrors test`);
+    }
+
     async execute(config: AppConfig, args?: CLIArguments, positionals?: string[]): Promise<void> {
-        // A ação vem como positional após "tomcat" (ex: xavva tomcat list)
+        if (args?.help) {
+            this.showHelp();
+            return;
+        }
+
         const tomcatIndex = positionals?.indexOf("tomcat") ?? -1;
         const action = positionals && tomcatIndex >= 0 && positionals[tomcatIndex + 1] 
             ? positionals[tomcatIndex + 1] 
             : "status";
         
-        // Argumentos extras após a ação (ex: xavva tomcat install 9.0.115)
         const extraArgs = positionals && tomcatIndex >= 0 ? positionals.slice(tomcatIndex + 2) : [];
         
         switch (action) {
@@ -21,10 +64,10 @@ export class TomcatCommand implements Command {
                 await this.handleInstall(config, args, extraArgs);
                 break;
             case "list":
-                this.handleList();
+                await this.handleList();
                 break;
             case "installed":
-                this.handleInstalled();
+                await this.handleInstalled();
                 break;
             case "use":
                 await this.handleUse(config, args, extraArgs);
@@ -32,61 +75,98 @@ export class TomcatCommand implements Command {
             case "uninstall":
                 await this.handleUninstall(config, args, extraArgs);
                 break;
+            case "backup":
+                await this.handleBackup(extraArgs);
+                break;
+            case "cache":
+                await this.handleCache(extraArgs);
+                break;
+            case "mirrors":
+                await this.handleMirrors(extraArgs);
+                break;
             case "status":
-                await this.handleStatus(config);
+                Logger.info("Status", "Tomcat manager avançado em desenvolvimento");
                 break;
             default:
                 Logger.error(`Ação desconhecida: ${action}`);
-                Logger.info("Ações disponíveis", "install, list, installed, use, uninstall, status");
+                Logger.info("Ações disponíveis", "install, list, installed, use, uninstall, backup, cache, mirrors, status");
         }
     }
 
     private async handleInstall(config: AppConfig, args?: CLIArguments, extraArgs: string[] = []): Promise<void> {
-        // Versão pode vir de: flag --tomcat-version, argumento posicional, config, ou padrão
-        const version = args?.["tomcat-version"] || extraArgs[0] || config.tomcat.version || "10.1.52";
-        
-        // Detectar webapp path
-        const webappPath = config.project.buildTool === "maven"
-            ? path.join(process.cwd(), "src", "main", "webapp")
-            : path.join(process.cwd(), "src", "main", "webapp");
-
-        const service = new EmbeddedTomcatService({
-            version,
-            port: config.tomcat.port,
-            webappPath
-        });
-
-        if (service.checkInstallation()) {
-            Logger.info("Tomcat", `Versão ${version} já está instalada`);
-            const info = service.getInfo();
-            Logger.config("Local", info.home);
-            return;
+        // Verifica modo paralelo
+        const isParallel = args?.parallel || extraArgs.includes("--parallel");
+        
+        // Coleta versões para instalar
+        let versions: string[] = [];
+        
+        // Versão via flag
+        if (args?.["tomcat-version"]) {
+            versions.push(args["tomcat-version"]);
         }
+        
+        // Versões via args extras (remove flags)
+        const versionArgs = extraArgs.filter(arg => !arg.startsWith("--"));
+        versions.push(...versionArgs);
+        
+        // Se nenhuma versão especificada, usa padrão ou config
+        if (versions.length === 0) {
+            versions.push(config.tomcat.version || "10.1.52");
+        }
+
+        // Remove duplicatas
+        versions = [...new Set(versions)];
 
-        const installed = await service.install();
-        if (installed) {
-            Logger.success(`Tomcat ${version} instalado com sucesso!`);
+        const installOptions = {
+            version: versions[0], // Será sobrescrito no loop/paralelo
+            mirror: args?.["tomcat-mirror"] as string | undefined,
+            verifyChecksum: !args?.["no-checksum"] && !extraArgs.includes("--no-checksum"),
+            useCache: !args?.["no-cache"] && !extraArgs.includes("--no-cache"),
+            backup: !args?.["no-backup"] && !extraArgs.includes("--no-backup"),
+            silent: args?.silent || extraArgs.includes("--silent"),
+            timeout: parseInt(args?.timeout as string || "300"),
+            retries: parseInt(args?.retries as string || "3"),
+            force: args?.force || extraArgs.includes("--force"),
+            projectPath: process.cwd()
+        };
+
+        if (isParallel && versions.length > 1) {
+            await this.installer.installParallel(versions, installOptions);
         } else {
-            Logger.error("Falha na instalação");
+            for (const version of versions) {
+                const result = await this.installer.install({
+                    ...installOptions,
+                    version
+                });
+
+                if (!result.success) {
+                    Logger.error(`Falha ao instalar ${version}: ${result.error}`);
+                }
+            }
         }
     }
 
-    private handleList(): void {
-        Logger.section("Versões Disponíveis para Download");
-        const versions = EmbeddedTomcatService.getAvailableVersions();
+    private async handleList(): Promise<void> {
+        Logger.section("Versões Disponíveis");
         
-        for (const version of versions) {
-            Logger.log(`  ${Logger.C.primary}•${Logger.C.reset} ${version}`);
-        }
+        const versions = ["11.0.6", "10.1.52", "10.0.27", "9.0.96", "8.5.100"];
         
+        Logger.log(`${C.bold}Recomendadas:${C.reset}`);
+        Logger.log(`  ${C.success}✓${C.reset} 10.1.52  - Jakarta EE 10, Servlet 6.0`);
+        Logger.log(`  ${C.success}✓${C.reset} 9.0.96   - Java EE 8, Servlet 4.0 (mais estável)`);
         Logger.newline();
-        Logger.info("Versão padrão", "10.1.52");
+        
+        Logger.log(`${C.bold}Outras versões:${C.reset}`);
+        Logger.log(`  ${C.primary}•${C.reset} 11.0.6   - Jakarta EE 11, requer Java 21`);
+        Logger.log(`  ${C.primary}•${C.reset} 10.0.27  - Jakarta EE 9 (legado)`);
+        Logger.log(`  ${C.primary}•${C.reset} 8.5.100  - Java EE 7 (legado)`);
         Logger.newline();
+        
         Logger.info("Dica", "Use 'xavva tomcat installed' para ver versões já instaladas");
     }
 
-    private handleInstalled(): void {
-        const installed = EmbeddedTomcatService.listInstalledVersions();
+    private async handleInstalled(): Promise<void> {
+        const installed = await this.installer.listInstalled();
         
         Logger.section("Versões Instaladas");
         
@@ -97,7 +177,9 @@ export class TomcatCommand implements Command {
         }
         
         for (const version of installed) {
-            Logger.log(`  ${Logger.C.success}✓${Logger.C.reset} ${version}`);
+            const sizeMB = (version.size / 1024 / 1024).toFixed(1);
+            Logger.log(`  ${C.success}✓${C.reset} ${C.bold}${version.version}${C.reset} (${sizeMB} MB)`);
+            Logger.log(`    ${C.gray}Local:${C.reset} ${version.home}`);
         }
         
         Logger.newline();
@@ -110,37 +192,28 @@ export class TomcatCommand implements Command {
         if (!version) {
             Logger.error("Versão não especificada");
             Logger.info("Uso", "xavva tomcat use <version>");
-            Logger.info("Exemplo", "xavva tomcat use 9.0.115");
+            Logger.info("Exemplo", "xavva tomcat use 10.1.52");
             Logger.newline();
-            Logger.info("Versões instaladas", "");
-            this.handleInstalled();
+            await this.handleInstalled();
             return;
         }
         
-        // Verifica se a versão está instalada
-        const service = new EmbeddedTomcatService({
-            version,
-            port: config.tomcat.port,
-            webappPath: "."
-        });
-        
-        if (!service.checkInstallation()) {
+        if (!this.installer.isInstalled(version)) {
             Logger.warn(`Tomcat ${version} não está instalado`);
             Logger.newline();
             Logger.info("Opções", "");
-            Logger.log(`  ${Logger.C.primary}1.${Logger.C.reset} Instalar agora: xavva tomcat install ${version}`);
-            Logger.log(`  ${Logger.C.primary}2.${Logger.C.reset} Ver instaladas: xavva tomcat installed`);
+            Logger.log(`  ${C.primary}1.${C.reset} Instalar agora: xavva tomcat install ${version}`);
+            Logger.log(`  ${C.primary}2.${C.reset} Ver instaladas: xavva tomcat installed`);
             return;
         }
         
-        // Salva a versão no xavva.json do projeto
         await this.saveTomcatVersion(version);
         
         Logger.success(`Tomcat ${version} configurado para este projeto!`);
         Logger.newline();
         Logger.info("Próximos comandos", "");
-        Logger.log(`  ${Logger.C.primary}•${Logger.C.reset} xavva dev    # Iniciar desenvolvimento`);
-        Logger.log(`  ${Logger.C.primary}•${Logger.C.reset} xavva deploy # Fazer deploy`);
+        Logger.log(`  ${C.primary}•${C.reset} xavva dev    # Iniciar desenvolvimento`);
+        Logger.log(`  ${C.primary}•${C.reset} xavva deploy # Fazer deploy`);
     }
 
     private async saveTomcatVersion(version: string): Promise<void> {
@@ -163,47 +236,118 @@ export class TomcatCommand implements Command {
     }
 
     private async handleUninstall(config: AppConfig, args?: CLIArguments, extraArgs: string[] = []): Promise<void> {
-        // Versão pode vir de: flag --tomcat-version, argumento posicional, config, ou padrão
-        const version = args?.["tomcat-version"] || extraArgs[0] || config.tomcat.version || "10.1.52";
+        const version = args?.["tomcat-version"] || extraArgs[0] || config.tomcat.version;
         
-        const service = new EmbeddedTomcatService({
-            version,
-            port: config.tomcat.port,
-            webappPath: "."
-        });
+        if (!version) {
+            Logger.error("Versão não especificada");
+            Logger.info("Uso", "xavva tomcat uninstall <version>");
+            return;
+        }
 
-        if (!service.checkInstallation()) {
+        if (!this.installer.isInstalled(version)) {
             Logger.warn(`Tomcat ${version} não está instalado`);
             return;
         }
 
         Logger.step(`Removendo Tomcat ${version}...`);
-        await service.uninstall();
-        Logger.success("Removido com sucesso!");
+        await this.installer.uninstall(version);
     }
 
-    private async handleStatus(config: AppConfig): Promise<void> {
-        Logger.section("Status do Tomcat");
-        
-        if (config.tomcat.embedded) {
-            Logger.config("Modo", "Embutido");
-            Logger.config("Versão", config.tomcat.version || "10.1.52");
-            Logger.config("Porta", String(config.tomcat.port));
-            Logger.config("Home", config.tomcat.path);
-        } else {
-            Logger.config("Modo", "Externo");
-            Logger.config("CATALINA_HOME", config.tomcat.path);
-            Logger.config("Porta", String(config.tomcat.port));
+    private async handleBackup(extraArgs: string[] = []): Promise<void> {
+        const subAction = extraArgs[0] || "list";
+
+        switch (subAction) {
+            case "list": {
+                const version = extraArgs[1];
+                const backups = await this.installer.listBackups(version);
+                
+                Logger.section("Backups Disponíveis");
+                
+                if (backups.length === 0) {
+                    Logger.warn("Nenhum backup encontrado");
+                    return;
+                }
+
+                for (const backup of backups) {
+                    const sizeMB = (backup.size / 1024 / 1024).toFixed(1);
+                    const date = backup.timestamp.toLocaleString();
+                    Logger.log(`  ${C.primary}•${C.reset} ${backup.version} - ${date} (${sizeMB} MB)`);
+                }
+                break;
+            }
+            case "restore": {
+                const version = extraArgs[1];
+                if (!version) {
+                    Logger.error("Versão não especificada");
+                    Logger.info("Uso", "xavva tomcat backup restore <version>");
+                    return;
+                }
+                
+                const success = await this.installer.restoreBackup(version);
+                if (success) {
+                    Logger.success(`Backup de ${version} restaurado!`);
+                } else {
+                    Logger.error("Falha ao restaurar backup");
+                }
+                break;
+            }
+            default:
+                Logger.error(`Ação de backup desconhecida: ${subAction}`);
+                Logger.info("Ações", "list, restore");
         }
-        
-        // Verificar se está rodando
-        const netstat = Bun.spawnSync(["cmd", "/c", `netstat -ano | findstr :${config.tomcat.port}`]);
-        const output = await new Response(netstat.stdout).text();
-        
-        if (output.trim()) {
-            Logger.config("Status", `${Logger.C.success}Rodando${Logger.C.reset}`);
-        } else {
-            Logger.config("Status", `${Logger.C.warning}Parado${Logger.C.reset}`);
+    }
+
+    private async handleCache(extraArgs: string[] = []): Promise<void> {
+        const subAction = extraArgs[0] || "stats";
+
+        switch (subAction) {
+            case "stats": {
+                const stats = await this.installer.getCacheStats();
+                const sizeMB = (stats.size / 1024 / 1024).toFixed(1);
+                
+                Logger.section("Estatísticas do Cache");
+                Logger.log(`  ${C.primary}•${C.reset} Arquivos: ${stats.files}`);
+                Logger.log(`  ${C.primary}•${C.reset} Tamanho: ${sizeMB} MB`);
+                break;
+            }
+            case "clear":
+                await this.installer.clearCache();
+                Logger.success("Cache limpo!");
+                break;
+            default:
+                Logger.error(`Ação de cache desconhecida: ${subAction}`);
+                Logger.info("Ações", "stats, clear");
+        }
+    }
+
+    private async handleMirrors(extraArgs: string[] = []): Promise<void> {
+        const { TomcatMirrorManager } = await import("../services/tomcat");
+        const manager = new TomcatMirrorManager();
+
+        const subAction = extraArgs[0] || "list";
+
+        switch (subAction) {
+            case "list": {
+                const mirrors = manager.getMirrors();
+                Logger.section("Mirrors Disponíveis");
+                for (const mirror of mirrors) {
+                    Logger.log(`  ${C.primary}•${C.reset} ${mirror.name} (${mirror.region})`);
+                }
+                break;
+            }
+            case "test": {
+                Logger.section("Testando Mirrors");
+                const tested = await manager.testAllMirrors();
+                
+                for (const mirror of tested.slice(0, 5)) {
+                    const color = mirror.latency < 200 ? C.success : mirror.latency < 500 ? C.warning : C.error;
+                    Logger.log(`  ${color}•${C.reset} ${mirror.name}: ${mirror.latency}ms`);
+                }
+                break;
+            }
+            default:
+                Logger.error(`Ação desconhecida: ${subAction}`);
+                Logger.info("Ações", "list, test");
         }
     }
 }

package/src/config/versions.ts

@@ -1,14 +1,18 @@
 /**
- * Configurações centralizadas de versões
- * Evita hardcoding espalhado pelo código
+ * Configurações centralizadas de versões e constantes
+ * Fonte única da verdade para todo o XAVVA CLI
  */
 
+// ============================================
+// VERSÕES
+// ============================================
+
 export const VERSIONS = {
     // Versões padrão do Tomcat
     TOMCAT: {
         DEFAULT: "10.1.52",
         AVAILABLE: {
-            "10.1.52": { sha512: "" },
+            "10.1.52": { sha512: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" },
             "9.0.115": { sha512: "" },
             "11.0.18": { sha512: "" },
         },
@@ -20,15 +24,113 @@ export const VERSIONS = {
         URL: "https://github.com/HotswapProjects/HotswapAgent/releases/download/RELEASE-{version}/hotswap-agent-{version}.jar",
     },
 
-    // Configurações padrão
-    DEFAULTS: {
-        TOMCAT_PORT: 8080,
-        DEBUG_PORT: 5005,
-        DEBOUNCE_MS: 300,
-        COOLING_MS: 1000,
+    // Requisitos
+    JDK: {
+        MIN: "11",
+        RECOMMENDED: "17",
     },
 } as const;
 
+// ============================================
+// PORTAS PADRÃO
+// ============================================
+
+export const PORTS = {
+    DEFAULT_TOMCAT: 8080,
+    DEFAULT_DEBUG: 5005,
+} as const;
+
+// ============================================
+// TIMEOUTS (ms)
+// ============================================
+
+export const TIMEOUTS = {
+    SHUTDOWN: 5000,
+    DEBOUNCE: 300,
+    COOLING: 1000,
+    WATCHER_DEBOUNCE: 1500,
+    BROWSER_OPEN: 800,
+    DEPLOY_HEALTH_CHECK: 1500,
+    HOTSWAP: 500,
+    TOMCAT_CLEAN_RETRY: 50,
+} as const;
+
+// ============================================
+// LIMITES E TAMANHOS
+// ============================================
+
+export const LIMITS = {
+    MAX_LOG_SCROLLBUFFER: 1000,
+    MAX_BUILD_ERRORS_SHOWN: 15,
+    MAX_HISTORY_ITEMS: 10,
+    MAX_DUPLICATE_LOGS: 5,
+    RATE_LIMIT_WINDOW_MS: 5000,
+    JAR_INTEGRITY_BUFFER_SIZE: 1024,
+    JAR_MIN_VALID_SIZE: 1000,
+    ZIP_EOCD_SIGNATURE_SIZE: 4,
+} as const;
+
+// ============================================
+// DASHBOARD
+// ============================================
+
+export const DASHBOARD = {
+    REFRESH_INTERVAL_MS: 1000,
+    LOG_SLICE_LINES: 1000,
+} as const;
+
+// ============================================
+// BUILD
+// ============================================
+
+export const BUILD = {
+    MAVEN_PARALLEL_THREADS: "1C",
+    JVM_MEMORY_OPTS: "-Xms512m -Xmx1024m -XX:+UseParallelGC",
+    GRADLE_MEMORY_OPTS: "-Xmx1024m -Dorg.gradle.daemon=true",
+} as const;
+
+// ============================================
+// EXIT CODES
+// ============================================
+
+export const EXIT_CODES = {
+    SUCCESS: 0,
+    GENERIC_ERROR: 1,
+    INVALID_COMMAND: 2,
+    BUILD_FAILED: 3,
+    DEPLOY_FAILED: 4,
+    TOMCAT_ERROR: 5,
+    PROJECT_ERROR: 6,
+    AUDIT_ERROR: 7,
+    NETWORK_ERROR: 8,
+    FILESYSTEM_ERROR: 9,
+    COMMAND_ERROR: 10,
+    SIGINT: 130,
+} as const;
+
+// ============================================
+// ARQUIVOS E DIRETÓRIOS
+// ============================================
+
+export const PATHS = {
+    JAVA_FILE_PATTERN: "**/*.java",
+    WAR_EXTENSION: ".war",
+    JAR_EXTENSION: ".jar",
+    XAVVA_DIR: ".xavva",
+    TARGET_DIR: "target",
+    BUILD_DIR: "build",
+    WEBAPP_DIR: "webapps",
+} as const;
+
+// ============================================
+// CACHE
+// ============================================
+
+export const CACHE = {
+    MAX_AGE_MS: 24 * 60 * 60 * 1000,
+    VERSION: 1,
+} as const;
+
 // Type helpers
 export type TomcatVersion = keyof typeof VERSIONS.TOMCAT.AVAILABLE;