@archznn/xavva 3.1.2 → 3.2.0

package/src/utils/constants.ts

@@ -1,54 +1,132 @@
 /**
  * Constantes da aplicação XAVVA CLI
  * 
- * Centraliza valores mágicos para facilitar manutenção e configuração.
+ * ⚠️ NOTA: Este arquivo re-exporta constantes de src/config/versions.ts
+ * para manter compatibilidade. Novo código deve importar diretamente
+ * de src/config/versions.ts
+ * 
+ * @deprecated Importe diretamente de src/config/versions.ts
  */
 
-// Ports padrão
+// Re-exportar todas as constantes centralizadas
+export {
+    VERSIONS,
+    PORTS,
+    TIMEOUTS,
+    LIMITS,
+    DASHBOARD,
+    BUILD,
+    EXIT_CODES,
+    PATHS,
+    CACHE,
+    // Types
+    type TomcatVersion,
+    // Functions
+    getHotswapAgentUrl,
+    isSupportedTomcatVersion,
+    getAvailableTomcatVersions,
+    getTomcatSha512,
+} from "../config/versions";
+
+// ============================================
+// ALIASES LEGACY (para compatibilidade)
+// ============================================
+
+/** @deprecated Use PORTS.DEFAULT_TOMCAT */
 export const DEFAULT_TOMCAT_PORT = 8080;
+
+/** @deprecated Use PORTS.DEFAULT_DEBUG */
 export const DEFAULT_DEBUG_PORT = 5005;
 
-// Timeouts (em milissegundos)
+/** @deprecated Use TIMEOUTS.SHUTDOWN */
 export const TIMEOUT_SHUTDOWN_MS = 5000;
+
+/** @deprecated Use TIMEOUTS.WATCHER_DEBOUNCE */
 export const WATCHER_DEBOUNCE_MS = 1500;
+
+/** @deprecated Use TIMEOUTS.COOLING */
 export const WATCHER_COOLING_MS = 1000;
+
+/** @deprecated Use TIMEOUTS.BROWSER_OPEN */
 export const BROWSER_OPEN_DELAY_MS = 800;
+
+/** @deprecated Use TIMEOUTS.DEPLOY_HEALTH_CHECK */
 export const DEPLOY_HEALTH_CHECK_DELAY_MS = 1500;
+
+/** @deprecated Use TIMEOUTS.HOTSWAP */
 export const HOTSWAP_DELAY_MS = 500;
+
+/** @deprecated Use TIMEOUTS.TOMCAT_CLEAN_RETRY */
 export const TOMCAT_CLEAN_RETRY_DELAY_MS = 50;
 
-// Tamanhos e limites
+/** @deprecated Use LIMITS.MAX_LOG_SCROLLBUFFER */
 export const MAX_LOG_SCROLLBUFFER = 1000;
+
+/** @deprecated Use LIMITS.MAX_BUILD_ERRORS_SHOWN */
 export const MAX_BUILD_ERRORS_SHOWN = 15;
+
+/** @deprecated Use LIMITS.MAX_HISTORY_ITEMS */
 export const MAX_HISTORY_ITEMS = 10;
+
+/** @deprecated Use LIMITS.JAR_INTEGRITY_BUFFER_SIZE */
 export const JAR_INTEGRITY_BUFFER_SIZE = 1024;
+
+/** @deprecated Use LIMITS.JAR_MIN_VALID_SIZE */
 export const JAR_MIN_VALID_SIZE = 1000;
+
+/** @deprecated Use LIMITS.ZIP_EOCD_SIGNATURE_SIZE */
 export const ZIP_EOCD_SIGNATURE_SIZE = 4;
 
-// Dashboard
+/** @deprecated Use DASHBOARD.REFRESH_INTERVAL_MS */
 export const DASHBOARD_REFRESH_INTERVAL_MS = 1000;
+
+/** @deprecated Use DASHBOARD.LOG_SLICE_LINES */
 export const DASHBOARD_LOG_SLICE_LINES = 1000;
 
-// Build
+/** @deprecated Use BUILD.MAVEN_PARALLEL_THREADS */
 export const MAVEN_PARALLEL_THREADS = "1C";
+
+/** @deprecated Use BUILD.JVM_MEMORY_OPTS */
 export const JVM_MEMORY_OPTS = "-Xms512m -Xmx1024m -XX:+UseParallelGC";
+
+/** @deprecated Use BUILD.GRADLE_MEMORY_OPTS */
 export const GRADLE_MEMORY_OPTS = "-Xmx1024m -Dorg.gradle.daemon=true";
 
-// Exit codes
+/** @deprecated Use EXIT_CODES.SUCCESS */
 export const EXIT_SUCCESS = 0;
+
+/** @deprecated Use EXIT_CODES.GENERIC_ERROR */
 export const EXIT_GENERIC_ERROR = 1;
+
+/** @deprecated Use EXIT_CODES.INVALID_COMMAND */
 export const EXIT_INVALID_COMMAND = 2;
+
+/** @deprecated Use EXIT_CODES.BUILD_FAILED */
 export const EXIT_BUILD_FAILED = 3;
+
+/** @deprecated Use EXIT_CODES.DEPLOY_FAILED */
 export const EXIT_DEPLOY_FAILED = 4;
+
+/** @deprecated Use EXIT_CODES.SIGINT */
 export const EXIT_SIGINT = 130;
 
-// File patterns
+/** @deprecated Use PATHS.JAVA_FILE_PATTERN */
 export const JAVA_FILE_PATTERN = "**/*.java";
+
+/** @deprecated Use PATHS.WAR_EXTENSION */
 export const WAR_EXTENSION = ".war";
+
+/** @deprecated Use PATHS.JAR_EXTENSION */
 export const JAR_EXTENSION = ".jar";
 
-// Directories
+/** @deprecated Use PATHS.XAVVA_DIR */
 export const XAVVA_DIR = ".xavva";
+
+/** @deprecated Use PATHS.TARGET_DIR */
 export const TARGET_DIR = "target";
+
+/** @deprecated Use PATHS.BUILD_DIR */
 export const BUILD_DIR = "build";
+
+/** @deprecated Use PATHS.WEBAPP_DIR */
 export const WEBAPP_DIR = "webapps";

package/src/utils/dryRun.ts

@@ -0,0 +1,192 @@
+/**
+ * Utilitários para modo Dry-Run (simulação)
+ * 
+ * Permite visualizar o que seria executado sem realmente executar
+ */
+
+import { Logger } from "../logging";
+
+export interface DryRunAction {
+    type: "command" | "file" | "network" | "config" | "warning";
+    description: string;
+    details?: string[];
+}
+
+export class DryRunSimulator {
+    private actions: DryRunAction[] = [];
+    private logger = Logger.getInstance();
+
+    /**
+     * Registra uma ação que seria executada
+     */
+    addCommand(command: string, args: string[] = []): void {
+        this.actions.push({
+            type: "command",
+            description: `Executar: ${command} ${args.join(" ")}`,
+            details: [`Comando: ${command}`, `Args: ${args.join(" ") || "(nenhum)"}`],
+        });
+    }
+
+    /**
+     * Registra uma operação de arquivo
+     */
+    addFileOperation(operation: "copy" | "move" | "delete" | "create", from: string, to?: string): void {
+        const descriptions: Record<string, string> = {
+            copy: `Copiar: ${from} → ${to}`,
+            move: `Mover: ${from} → ${to}`,
+            delete: `Excluir: ${from}`,
+            create: `Criar: ${from}`,
+        };
+
+        this.actions.push({
+            type: "file",
+            description: descriptions[operation],
+            details: [from, to].filter(Boolean),
+        });
+    }
+
+    /**
+     * Registra uma requisição de rede
+     */
+    addNetworkRequest(method: string, url: string, body?: string): void {
+        this.actions.push({
+            type: "network",
+            description: `${method.toUpperCase()} ${url}`,
+            details: body ? [`Body: ${body}`] : undefined,
+        });
+    }
+
+    /**
+     * Registra uma mudança de configuração
+     */
+    addConfigChange(key: string, oldValue: string, newValue: string): void {
+        this.actions.push({
+            type: "config",
+            description: `Config: ${key} = ${newValue}`,
+            details: [`Anterior: ${oldValue}`, `Novo: ${newValue}`],
+        });
+    }
+
+    /**
+     * Adiciona um aviso
+     */
+    addWarning(message: string): void {
+        this.actions.push({
+            type: "warning",
+            description: `⚠️  ${message}`,
+        });
+    }
+
+    /**
+     * Mostra o relatório de simulação
+     */
+    printReport(): void {
+        this.logger.section("Modo Dry-Run (Simulação)");
+        this.logger.info("Nenhuma alteração será feita. Ações que seriam executadas:");
+        this.logger.newline();
+
+        // Agrupa por tipo
+        const byType: Record<string, DryRunAction[]> = {};
+        for (const action of this.actions) {
+            if (!byType[action.type]) byType[action.type] = [];
+            byType[action.type].push(action);
+        }
+
+        // Mostra comandos
+        if (byType["command"]) {
+            this.logger.info("📋 Comandos:");
+            for (const action of byType["command"]) {
+                this.logger.info(`   $ ${action.description}`);
+            }
+            this.logger.newline();
+        }
+
+        // Mostra operações de arquivo
+        if (byType["file"]) {
+            this.logger.info("📁 Arquivos:");
+            for (const action of byType["file"]) {
+                this.logger.info(`   ${action.description}`);
+            }
+            this.logger.newline();
+        }
+
+        // Mostra requisições de rede
+        if (byType["network"]) {
+            this.logger.info("🌐 Rede:");
+            for (const action of byType["network"]) {
+                this.logger.info(`   ${action.description}`);
+            }
+            this.logger.newline();
+        }
+
+        // Mostra mudanças de config
+        if (byType["config"]) {
+            this.logger.info("⚙️  Configurações:");
+            for (const action of byType["config"]) {
+                this.logger.info(`   ${action.description}`);
+                if (action.details) {
+                    for (const detail of action.details) {
+                        this.logger.info(`      ${detail}`);
+                    }
+                }
+            }
+            this.logger.newline();
+        }
+
+        // Mostra avisos
+        if (byType["warning"]) {
+            this.logger.warn("⚠️  Avisos:");
+            for (const action of byType["warning"]) {
+                this.logger.warn(`   ${action.description}`);
+            }
+            this.logger.newline();
+        }
+
+        this.logger.divider();
+        this.logger.info(`Total de ações: ${this.actions.length}`);
+    }
+
+    /**
+     * Limpa as ações registradas
+     */
+    clear(): void {
+        this.actions = [];
+    }
+
+    /**
+     * Retorna todas as ações
+     */
+    getActions(): DryRunAction[] {
+        return [...this.actions];
+    }
+}
+
+// Singleton global
+let globalSimulator: DryRunSimulator | null = null;
+
+export function getDryRunSimulator(): DryRunSimulator {
+    if (!globalSimulator) {
+        globalSimulator = new DryRunSimulator();
+    }
+    return globalSimulator;
+}
+
+export function resetDryRunSimulator(): void {
+    globalSimulator = null;
+}
+
+/**
+ * Wrapper para executar função em modo dry-run ou real
+ */
+export async function withDryRun<T>(
+    isDryRun: boolean,
+    fn: () => Promise<T>,
+    simulator?: DryRunSimulator
+): Promise<T | void> {
+    if (isDryRun) {
+        const sim = simulator || getDryRunSimulator();
+        sim.printReport();
+        return;
+    }
+    return fn();
+}

package/src/utils/processManager.ts

@@ -15,6 +15,8 @@ import {
     TIMEOUT_SHUTDOWN_MS 
 } from "./constants";
 
+import { Logger } from "../logging";
+
 export type ExitCode = 
     | typeof EXIT_SUCCESS
     | typeof EXIT_GENERIC_ERROR
@@ -32,6 +34,7 @@ export class ProcessManager {
     private shutdownHandlers: Set<ShutdownHandler> = new Set();
     private isShuttingDown = false;
     private exitCode: ExitCode = 0;
+    private logger = Logger.getInstance();
 
     private constructor() {
         this.setupSignalHandlers();
@@ -85,19 +88,23 @@ export class ProcessManager {
         }
 
         // Executa handlers em paralelo com timeout
+        this.logger.debug("Iniciando graceful shutdown...");
+        
         const timeoutMs = TIMEOUT_SHUTDOWN_MS;
         const handlerPromises = Array.from(this.shutdownHandlers).map(async (handler) => {
             try {
                 const timeoutPromise = new Promise((_, reject) => 
-                    setTimeout(() => reject(new Error('Shutdown handler timeout')), timeoutMs)
+                    setTimeout(() => reject(new Error('Timeout do shutdown handler')), timeoutMs)
                 );
                 await Promise.race([handler(), timeoutPromise]);
             } catch (e) {
-                console.error('Erro em shutdown handler:', e);
+                this.logger.error(`Erro em shutdown handler: ${(e as Error).message}`);
             }
         });
 
         await Promise.all(handlerPromises);
+        
+        this.logger.debug(`Shutdown completo (exit code: ${this.exitCode})`);
 
         // Em ambiente de teste, não chama process.exit()
         if (process.env.NODE_ENV === 'test' || process.env.BUN_ENV === 'test') {
@@ -112,6 +119,8 @@ export class ProcessManager {
      * Use apenas em casos críticos onde não é seguro continuar.
      */
     exit(code: ExitCode): never {
+        this.logger.error(`Exit imediato solicitado (código: ${code})`);
+        
         if (process.env.NODE_ENV === 'test' || process.env.BUN_ENV === 'test') {
             throw new ProcessExitError(code);
         }
@@ -119,16 +128,23 @@ export class ProcessManager {
     }
 
     private setupSignalHandlers(): void {
-        process.on('SIGINT', () => this.shutdown(EXIT_SIGINT));
-        process.on('SIGTERM', () => this.shutdown(0));
+        process.on('SIGINT', () => {
+            this.logger.debug("SIGINT recebido");
+            this.shutdown(EXIT_SIGINT);
+        });
+        
+        process.on('SIGTERM', () => {
+            this.logger.debug("SIGTERM recebido");
+            this.shutdown(0);
+        });
         
         process.on('unhandledRejection', (reason, promise) => {
-            console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+            this.logger.error("Unhandled Rejection:", { reason: String(reason) });
             this.shutdown(1);
         });
 
         process.on('uncaughtException', (error) => {
-            console.error('Uncaught Exception:', error);
+            this.logger.error("Uncaught Exception:", { message: error.message, stack: error.stack });
             this.shutdown(1);
         });
     }
@@ -139,7 +155,7 @@ export class ProcessManager {
  */
 export class ProcessExitError extends Error {
     constructor(public readonly code: ExitCode) {
-        super(`Process exited with code ${code}`);
+        super(`Processo encerrou com código ${code}`);
         this.name = 'ProcessExitError';
     }
 }