@archznn/xavva 2.0.3 → 2.2.0

package/src/utils/config.ts

@@ -1,6 +1,7 @@
 import { parseArgs } from "util";
 import path from "path";
 import fs from "fs";
+import { DEFAULT_TOMCAT_PORT, DEFAULT_DEBUG_PORT } from "./constants";
 import type { AppConfig, CLIArguments, CommandContext } from "../types/config";
 
 export class ConfigManager {
@@ -25,9 +26,12 @@ export class ConfigManager {
                 profile: { type: "string", short: "P" },
                 grep: { type: "string", short: "G" },
                 verbose: { type: "boolean", short: "V" },
+                encoding: { type: "string", short: "e" },
                 dp: { type: "string" },
                 fix: { type: "boolean" },
                 tui: { type: "boolean" },
+                output: { type: "string", short: "o" },
+                strict: { type: "boolean" },
             },
             strict: false,
             allowPositionals: true,
@@ -63,7 +67,7 @@ export class ConfigManager {
         const config: AppConfig = {
             tomcat: {
                 path: String(cliValues.path || xavvaJson.path || envTomcatPath),
-                port: parseInt(String(cliValues.port || xavvaJson.port || "8080")),
+                port: parseInt(String(cliValues.port || xavvaJson.port || String(DEFAULT_TOMCAT_PORT))),
                 webapps: "webapps",
                 grep: cliValues.grep || xavvaJson.grep ? String(cliValues.grep || xavvaJson.grep) : "",
             },
@@ -78,9 +82,10 @@ export class ConfigManager {
                 quiet: (cliValues.verbose ?? xavvaJson.verbose) ? false : true,
                 verbose: !!(cliValues.verbose ?? xavvaJson.verbose),
                 debug: !!(cliValues.debug ?? xavvaJson.debug ?? isDev ?? isRun),
-                debugPort: parseInt(String(cliValues.dp || xavvaJson.dp || "5005")),
+                debugPort: parseInt(String(cliValues.dp || xavvaJson.dp || String(DEFAULT_DEBUG_PORT))),
                 grep: runClass || (cliValues.grep || xavvaJson.grep ? String(cliValues.grep || xavvaJson.grep) : ""),
                 tui: !!(cliValues.tui ?? xavvaJson.tui),
+                encoding: cliValues.encoding || xavvaJson.encoding || "",
             }
         };
 

package/src/utils/constants.ts

@@ -0,0 +1,54 @@
+/**
+ * Constantes da aplicação XAVVA CLI
+ * 
+ * Centraliza valores mágicos para facilitar manutenção e configuração.
+ */
+
+// Ports padrão
+export const DEFAULT_TOMCAT_PORT = 8080;
+export const DEFAULT_DEBUG_PORT = 5005;
+
+// Timeouts (em milissegundos)
+export const TIMEOUT_SHUTDOWN_MS = 5000;
+export const WATCHER_DEBOUNCE_MS = 1000;
+export const WATCHER_COOLING_MS = 500;
+export const BROWSER_OPEN_DELAY_MS = 800;
+export const DEPLOY_HEALTH_CHECK_DELAY_MS = 1500;
+export const HOTSWAP_DELAY_MS = 500;
+export const TOMCAT_CLEAN_RETRY_DELAY_MS = 50;
+
+// Tamanhos e limites
+export const MAX_LOG_SCROLLBUFFER = 1000;
+export const MAX_BUILD_ERRORS_SHOWN = 15;
+export const MAX_HISTORY_ITEMS = 10;
+export const JAR_INTEGRITY_BUFFER_SIZE = 1024;
+export const JAR_MIN_VALID_SIZE = 1000;
+export const ZIP_EOCD_SIGNATURE_SIZE = 4;
+
+// Dashboard
+export const DASHBOARD_REFRESH_INTERVAL_MS = 1000;
+export const DASHBOARD_LOG_SLICE_LINES = 1000;
+
+// Build
+export const MAVEN_PARALLEL_THREADS = "1C";
+export const JVM_MEMORY_OPTS = "-Xms512m -Xmx1024m -XX:+UseParallelGC";
+export const GRADLE_MEMORY_OPTS = "-Xmx1024m -Dorg.gradle.daemon=true";
+
+// Exit codes
+export const EXIT_SUCCESS = 0;
+export const EXIT_GENERIC_ERROR = 1;
+export const EXIT_INVALID_COMMAND = 2;
+export const EXIT_BUILD_FAILED = 3;
+export const EXIT_DEPLOY_FAILED = 4;
+export const EXIT_SIGINT = 130;
+
+// File patterns
+export const JAVA_FILE_PATTERN = "**/*.java";
+export const WAR_EXTENSION = ".war";
+export const JAR_EXTENSION = ".jar";
+
+// Directories
+export const XAVVA_DIR = ".xavva";
+export const TARGET_DIR = "target";
+export const BUILD_DIR = "build";
+export const WEBAPP_DIR = "webapps";

package/src/utils/processManager.ts

@@ -0,0 +1,145 @@
+/**
+ * ProcessManager - Centraliza o controle do ciclo de vida da aplicação.
+ * 
+ * Evita chamadas diretas a process.exit() espalhadas pelo código,
+ * facilitando testes e permitindo graceful shutdown.
+ */
+
+import { 
+    EXIT_SUCCESS, 
+    EXIT_GENERIC_ERROR, 
+    EXIT_INVALID_COMMAND, 
+    EXIT_BUILD_FAILED, 
+    EXIT_DEPLOY_FAILED, 
+    EXIT_SIGINT,
+    TIMEOUT_SHUTDOWN_MS 
+} from "./constants";
+
+export type ExitCode = 
+    | typeof EXIT_SUCCESS
+    | typeof EXIT_GENERIC_ERROR
+    | typeof EXIT_INVALID_COMMAND
+    | typeof EXIT_BUILD_FAILED
+    | typeof EXIT_DEPLOY_FAILED
+    | typeof EXIT_SIGINT;
+
+interface ShutdownHandler {
+    (): Promise<void> | void;
+}
+
+export class ProcessManager {
+    private static instance: ProcessManager;
+    private shutdownHandlers: Set<ShutdownHandler> = new Set();
+    private isShuttingDown = false;
+    private exitCode: ExitCode = 0;
+
+    private constructor() {
+        this.setupSignalHandlers();
+    }
+
+    static getInstance(): ProcessManager {
+        if (!ProcessManager.instance) {
+            ProcessManager.instance = new ProcessManager();
+        }
+        return ProcessManager.instance;
+    }
+
+    /**
+     * Registra um handler para ser executado no shutdown.
+     * Útil para liberar recursos (fechar conexões, limpar arquivos temp, etc).
+     */
+    onShutdown(handler: ShutdownHandler): () => void {
+        this.shutdownHandlers.add(handler);
+        // Retorna função para remover o handler
+        return () => this.shutdownHandlers.delete(handler);
+    }
+
+    /**
+     * Define o código de saída sem encerrar imediatamente.
+     * O código real será usado quando shutdown() for chamado.
+     */
+    setExitCode(code: ExitCode): void {
+        this.exitCode = code;
+    }
+
+    /**
+     * Obtém o código de saída atual.
+     */
+    getExitCode(): ExitCode {
+        return this.exitCode;
+    }
+
+    /**
+     * Executa graceful shutdown com todos os handlers registrados.
+     * Por padrão chama process.exit(), mas pode ser mockado em testes.
+     */
+    async shutdown(code?: ExitCode): Promise<never> {
+        if (this.isShuttingDown) {
+            // Evita chamadas duplicadas
+            return new Promise(() => {}) as never;
+        }
+
+        this.isShuttingDown = true;
+        if (code !== undefined) {
+            this.exitCode = code;
+        }
+
+        // Executa handlers em paralelo com timeout
+        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)
+                );
+                await Promise.race([handler(), timeoutPromise]);
+            } catch (e) {
+                console.error('Erro em shutdown handler:', e);
+            }
+        });
+
+        await Promise.all(handlerPromises);
+
+        // Em ambiente de teste, não chama process.exit()
+        if (process.env.NODE_ENV === 'test' || process.env.BUN_ENV === 'test') {
+            throw new ProcessExitError(this.exitCode);
+        }
+
+        process.exit(this.exitCode);
+    }
+
+    /**
+     * Encerra imediatamente sem graceful shutdown.
+     * Use apenas em casos críticos onde não é seguro continuar.
+     */
+    exit(code: ExitCode): never {
+        if (process.env.NODE_ENV === 'test' || process.env.BUN_ENV === 'test') {
+            throw new ProcessExitError(code);
+        }
+        process.exit(code);
+    }
+
+    private setupSignalHandlers(): void {
+        process.on('SIGINT', () => this.shutdown(EXIT_SIGINT));
+        process.on('SIGTERM', () => this.shutdown(0));
+        
+        process.on('unhandledRejection', (reason, promise) => {
+            console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+            this.shutdown(1);
+        });
+
+        process.on('uncaughtException', (error) => {
+            console.error('Uncaught Exception:', error);
+            this.shutdown(1);
+        });
+    }
+}
+
+/**
+ * Erro especial para identificar chamadas a process.exit() em testes.
+ */
+export class ProcessExitError extends Error {
+    constructor(public readonly code: ExitCode) {
+        super(`Process exited with code ${code}`);
+        this.name = 'ProcessExitError';
+    }
+}