@archznn/xavva 2.6.0 → 2.8.0

package/src/services/FileWatcher.ts

@@ -0,0 +1,243 @@
+/**
+ * FileWatcher genérico
+ * Responsabilidade única: observar mudanças em arquivos
+ * Sem acoplamento com lógica de deploy
+ */
+
+import { watch, type FSWatcher } from "fs";
+import { Logger } from "../utils/ui";
+
+export interface FileWatcherOptions {
+    recursive?: boolean;
+    debounceMs?: number;
+    coolingMs?: number;
+    ignoredPatterns?: RegExp[];
+}
+
+export interface FileChangeEvent {
+    eventType: "rename" | "change";
+    filename: string | null;
+    fullPath: string;
+}
+
+export type FileChangeHandler = (event: FileChangeEvent) => void | Promise<void>;
+
+export class FileWatcher {
+    private watcher: FSWatcher | null = null;
+    private options: Required<FileWatcherOptions>;
+    private handlers: Map<string, FileChangeHandler> = new Map();
+    private debounceTimers: Map<string, Timer> = new Map();
+    private coolingFiles: Set<string> = new Set();
+    private isWatching = false;
+
+    private static readonly DEFAULT_OPTIONS: Required<FileWatcherOptions> = {
+        recursive: true,
+        debounceMs: 300,
+        coolingMs: 1000,
+        ignoredPatterns: [
+            /node_modules/,
+            /\.git/,
+            /target/,
+            /build/,
+            /\.xavva/,
+            /\.idea/,
+            /\.vscode/,
+            /dist/,
+            /out/,
+        ],
+    };
+
+    constructor(options: FileWatcherOptions = {}) {
+        this.options = { ...FileWatcher.DEFAULT_OPTIONS, ...options };
+    }
+
+    /**
+     * Registra um handler para um padrão específico
+     */
+    on(pattern: string | RegExp, handler: FileChangeHandler): () => void {
+        const key = pattern.toString();
+        this.handlers.set(key, handler);
+        
+        // Retorna função para remover handler
+        return () => this.handlers.delete(key);
+    }
+
+    /**
+     * Registra handler para qualquer mudança
+     */
+    onAny(handler: FileChangeHandler): () => void {
+        return this.on("*", handler);
+    }
+
+    /**
+     * Inicia o watching
+     */
+    start(rootPath: string = process.cwd()): void {
+        if (this.isWatching) {
+            Logger.debug("FileWatcher já está rodando");
+            return;
+        }
+
+        this.watcher = watch(
+            rootPath,
+            { recursive: this.options.recursive },
+            (eventType, filename) => this.handleWatchEvent(eventType, filename)
+        );
+
+        this.isWatching = true;
+        Logger.debug(`FileWatcher iniciado em ${rootPath}`);
+    }
+
+    /**
+     * Para o watching
+     */
+    stop(): void {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        
+        // Limpa timers pendentes
+        this.debounceTimers.forEach(timer => clearTimeout(timer));
+        this.debounceTimers.clear();
+        
+        this.isWatching = false;
+        Logger.debug("FileWatcher parado");
+    }
+
+    /**
+     * Verifica se está observando
+     */
+    isActive(): boolean {
+        return this.isWatching;
+    }
+
+    /**
+     * Processa evento do fs.watch
+     */
+    private handleWatchEvent(
+        eventType: "rename" | "change",
+        filename: string | null
+    ): void {
+        if (!filename) return;
+
+        // Ignora arquivos em cooling
+        if (this.coolingFiles.has(filename)) return;
+        this.addToCooling(filename);
+
+        // Ignora patterns definidos
+        if (this.isIgnored(filename)) return;
+
+        const fullPath = this.resolvePath(filename);
+        const event: FileChangeEvent = { eventType, filename, fullPath };
+
+        // Aplica debounce
+        this.debounce(filename, () => {
+            this.notifyHandlers(event);
+        });
+    }
+
+    /**
+     * Adiciona arquivo ao período de cooling
+     */
+    private addToCooling(filename: string): void {
+        this.coolingFiles.add(filename);
+        setTimeout(() => {
+            this.coolingFiles.delete(filename);
+        }, this.options.coolingMs);
+    }
+
+    /**
+     * Verifica se arquivo deve ser ignorado
+     */
+    private isIgnored(filename: string): boolean {
+        return this.options.ignoredPatterns.some(pattern => pattern.test(filename));
+    }
+
+    /**
+     * Resolve caminho completo
+     */
+    private resolvePath(filename: string): string {
+        // Normaliza separadores de path
+        return filename.replace(/\\/g, "/");
+    }
+
+    /**
+     * Aplica debounce no handler
+     */
+    private debounce(key: string, fn: () => void): void {
+        const existing = this.debounceTimers.get(key);
+        if (existing) {
+            clearTimeout(existing);
+        }
+
+        const timer = setTimeout(() => {
+            this.debounceTimers.delete(key);
+            fn();
+        }, this.options.debounceMs);
+
+        this.debounceTimers.set(key, timer);
+    }
+
+    /**
+     * Notifica todos os handlers relevantes
+     */
+    private notifyHandlers(event: FileChangeEvent): void {
+        // Notifica handlers específicos
+        for (const [pattern, handler] of this.handlers) {
+            if (this.matchesPattern(event.filename, pattern)) {
+                try {
+                    const result = handler(event);
+                    if (result instanceof Promise) {
+                        result.catch(err => {
+                            Logger.debug(`Erro em handler de watch: ${err.message}`);
+                        });
+                    }
+                } catch (err) {
+                    Logger.debug(`Erro em handler de watch: ${(err as Error).message}`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Verifica se filename match com pattern
+     */
+    private matchesPattern(filename: string | null, pattern: string): boolean {
+        if (!filename) return false;
+        if (pattern === "*") return true;
+        
+        try {
+            const regex = new RegExp(pattern);
+            return regex.test(filename);
+        } catch {
+            // Se não for regex válido, trata como string simples
+            return filename.includes(pattern);
+        }
+    }
+}
+
+/**
+ * Helper para criar watcher com configuração padrão de projetos Java
+ */
+export function createJavaFileWatcher(): FileWatcher {
+    return new FileWatcher({
+        recursive: true,
+        debounceMs: 300,
+        coolingMs: 1000,
+        ignoredPatterns: [
+            /node_modules/,
+            /\.git/,
+            /target/,
+            /build/,
+            /\.xavva/,
+            /\.idea/,
+            /\.vscode/,
+            /dist/,
+            /out/,
+            /\.class$/,
+            /\.jar$/,
+            /\.war$/,
+        ],
+    });
+}

package/src/services/HistoryService.ts

@@ -0,0 +1,73 @@
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export interface HistoryEntry {
+    command: string;
+    args: string[];
+    timestamp: string;
+    success: boolean;
+    duration?: number;
+}
+
+const HISTORY_FILE = join(homedir(), ".xavva", "history.json");
+const MAX_HISTORY_SIZE = 100;
+
+export class HistoryService {
+    private async ensureDir(): Promise<void> {
+        const dir = join(homedir(), ".xavva");
+        if (!existsSync(dir)) {
+            await mkdir(dir, { recursive: true });
+        }
+    }
+
+    private async load(): Promise<HistoryEntry[]> {
+        try {
+            await this.ensureDir();
+            const data = await readFile(HISTORY_FILE, "utf-8");
+            return JSON.parse(data);
+        } catch {
+            return [];
+        }
+    }
+
+    private async save(entries: HistoryEntry[]): Promise<void> {
+        await this.ensureDir();
+        // Keep only last MAX_HISTORY_SIZE entries
+        const trimmed = entries.slice(-MAX_HISTORY_SIZE);
+        await writeFile(HISTORY_FILE, JSON.stringify(trimmed, null, 2));
+    }
+
+    async add(entry: Omit<HistoryEntry, "timestamp">): Promise<void> {
+        const entries = await this.load();
+        entries.push({
+            ...entry,
+            timestamp: new Date().toISOString()
+        });
+        await this.save(entries);
+    }
+
+    async getRecent(limit: number = 10): Promise<HistoryEntry[]> {
+        const entries = await this.load();
+        return entries.slice(-limit).reverse();
+    }
+
+    async getLast(): Promise<HistoryEntry | null> {
+        const entries = await this.load();
+        return entries.length > 0 ? entries[entries.length - 1] : null;
+    }
+
+    async clear(): Promise<void> {
+        await this.save([]);
+    }
+
+    async getStats(): Promise<{ total: number; successful: number; failed: number }> {
+        const entries = await this.load();
+        return {
+            total: entries.length,
+            successful: entries.filter(e => e.success).length,
+            failed: entries.filter(e => !e.success).length
+        };
+    }
+}

package/src/services/NotificationService.ts

@@ -0,0 +1,145 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import { platform } from "os";
+
+const execAsync = promisify(exec);
+
+export interface NotificationOptions {
+    title: string;
+    message: string;
+    type?: "info" | "success" | "warning" | "error";
+    sound?: boolean;
+}
+
+export class NotificationService {
+    private static enabled = true;
+
+    static disable(): void {
+        this.enabled = false;
+    }
+
+    static enable(): void {
+        this.enabled = true;
+    }
+
+    static async notify(options: NotificationOptions): Promise<void> {
+        if (!this.enabled) return;
+
+        const { title, message, type = "info", sound = false } = options;
+
+        try {
+            if (platform() === "win32") {
+                await this.notifyWindows(title, message, type, sound);
+            } else if (platform() === "darwin") {
+                await this.notifyMacOS(title, message, type, sound);
+            } else {
+                await this.notifyLinux(title, message, type, sound);
+            }
+        } catch {
+            // Silently fail - notifications are not critical
+        }
+    }
+
+    private static async notifyWindows(
+        title: string, 
+        message: string, 
+        type: string, 
+        sound: boolean
+    ): Promise<void> {
+        // Use PowerShell notification
+        const iconMap: Record<string, string> = {
+            info: "Information",
+            success: "Information",
+            warning: "Warning",
+            error: "Error"
+        };
+
+        const psScript = `
+            Add-Type -AssemblyName System.Windows.Forms
+            $notify = New-Object System.Windows.Forms.NotifyIcon
+            $notify.Icon = [System.Drawing.SystemIcons]::${iconMap[type]}
+            $notify.BalloonTipTitle = "${title.replace(/"/g, '""')}"
+            $notify.BalloonTipText = "${message.replace(/"/g, '""')}"
+            $notify.BalloonTipIcon = "${iconMap[type]}"
+            $notify.Visible = $true
+            $notify.ShowBalloonTip(5000)
+        `;
+
+        await execAsync(`powershell -Command "${psScript}"`);
+    }
+
+    private static async notifyMacOS(
+        title: string, 
+        message: string, 
+        _type: string, 
+        sound: boolean
+    ): Promise<void> {
+        const soundFlag = sound ? '"\\"\\""' : "";
+        await execAsync(`osascript -e 'display notification "${message.replace(/"/g, '\\"')}" with title "${title.replace(/"/g, '\\"')}"${soundFlag}'`);
+    }
+
+    private static async notifyLinux(
+        title: string, 
+        message: string, 
+        type: string, 
+        _sound: boolean
+    ): Promise<void> {
+        const urgencyMap: Record<string, string> = {
+            info: "normal",
+            success: "normal",
+            warning: "normal",
+            error: "critical"
+        };
+
+        const iconMap: Record<string, string> = {
+            info: "dialog-information",
+            success: "dialog-information",
+            warning: "dialog-warning",
+            error: "dialog-error"
+        };
+
+        try {
+            await execAsync(`notify-send -u ${urgencyMap[type]} -i ${iconMap[type]} "${title}" "${message}"`);
+        } catch {
+            // Fallback: try zenity
+            try {
+                await execAsync(`zenity --info --title="${title}" --text="${message}" --timeout=5`);
+            } catch {
+                // No notification available
+            }
+        }
+    }
+
+    // Convenience methods
+    static buildSuccess(duration: number): Promise<void> {
+        return this.notify({
+            title: "Xavva - Build Completo",
+            message: `Build finalizado com sucesso em ${duration.toFixed(1)}s`,
+            type: "success"
+        });
+    }
+
+    static buildFailed(error: string): Promise<void> {
+        return this.notify({
+            title: "Xavva - Build Falhou",
+            message: error.slice(0, 100),
+            type: "error"
+        });
+    }
+
+    static deployComplete(appName: string): Promise<void> {
+        return this.notify({
+            title: "Xavva - Deploy Completo",
+            message: `${appName} implantado com sucesso`,
+            type: "success"
+        });
+    }
+
+    static watchReady(): Promise<void> {
+        return this.notify({
+            title: "Xavva - Watch Mode",
+            message: "Monitorando alterações nos arquivos...",
+            type: "info"
+        });
+    }
+}

package/src/services/TomcatService.ts

@@ -1,5 +1,8 @@
-import type { TomcatConfig, AppConfig } from "../types/config";
+import type { TomcatConfig, AppConfig } from "../types";
+import { getHotswapAgentUrl, VERSIONS } from "../config/versions";
+import { NetworkError } from "../errors/XavvaError";
 import { Logger } from "../utils/ui";
+import { ProgressBar, ThemedSpinner } from "../utils/ProgressBar";
 import type { Subprocess } from "bun";
 import { ProjectService } from "./ProjectService";
 import { existsSync, mkdirSync, writeFileSync, statSync, promises as fs } from "fs";
@@ -21,6 +24,7 @@ export class TomcatService {
 	public onReady?: () => void;
 	private pid: number | null = null;
 	private projectService: ProjectService | null = null;
+	private hasReadyBeenCalled: boolean = false;
 
 	constructor(customConfig: TomcatConfig) {
 		this.activeConfig = customConfig;
@@ -136,54 +140,82 @@ export class TomcatService {
 
 	private async ensureHotswapAgent(): Promise<string | null> {
 		const agentDir = path.join(os.homedir(), ".xavva", "agents");
-		const agentPath = path.join(agentDir, "hotswap-agent-2.0.3.jar");
+		const agentPath = path.join(agentDir, `hotswap-agent-${VERSIONS.HOTSWAP_AGENT.VERSION}.jar`);
 
 		if (existsSync(agentPath) && statSync(agentPath).size > 1000) return agentPath;
 
 		try {
 			if (!existsSync(agentDir)) mkdirSync(agentDir, { recursive: true });
 			
-			Logger.step("Downloading HotswapAgent v2.0.3 (Global)...");
-			const url = "https://github.com/HotswapProjects/HotswapAgent/releases/download/RELEASE-2.0.3/hotswap-agent-2.0.3.jar";
-			
-			Logger.debug(`URL: ${url}`);
-			Logger.debug(`Destino: ${agentPath}`);
-			
-			const response = await fetch(url, {
-				redirect: "follow",
-			});
+			const url = getHotswapAgentUrl();
+			const response = await fetch(url, { redirect: "follow" });
 			
 			if (!response.ok) {
 				throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 			}
 			
-			const contentLength = response.headers.get("content-length");
-			Logger.debug(`Content-Length: ${contentLength || "unknown"}`);
+			const totalSize = parseInt(response.headers.get("content-length") || "0");
 			
-			const buffer = await response.arrayBuffer();
-			Logger.debug(`Downloaded: ${buffer.byteLength} bytes`);
-			
-			if (buffer.byteLength < 1000) {
-				throw new Error(`Arquivo muito pequeno (${buffer.byteLength} bytes)`);
+			if (totalSize > 0) {
+				// Usar progress bar
+				const progress = new ProgressBar({
+					title: `Baixando HotswapAgent v${VERSIONS.HOTSWAP_AGENT.VERSION}`,
+					total: totalSize,
+					width: 25
+				});
+
+				const reader = response.body?.getReader();
+				if (!reader) throw new Error("Response body não disponível");
+
+				const chunks: Uint8Array[] = [];
+				let received = 0;
+
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					
+					chunks.push(value);
+					received += value.length;
+					progress.update(received);
+				}
+
+				progress.complete();
+
+				// Concatena e salva
+				const allChunks = new Uint8Array(received);
+				let position = 0;
+				for (const chunk of chunks) {
+					allChunks.set(chunk, position);
+					position += chunk.length;
+				}
+
+				await fs.writeFile(agentPath, allChunks);
+			} else {
+				// Sem content-length, usar spinner
+				const spinner = new ThemedSpinner();
+				const stop = spinner.start(`Baixando HotswapAgent v${VERSIONS.HOTSWAP_AGENT.VERSION}`, "dots", "download");
+				
+				const buffer = await response.arrayBuffer();
+				writeFileSync(agentPath, Buffer.from(buffer));
+				
+				stop(true);
 			}
 			
-			writeFileSync(agentPath, Buffer.from(buffer));
-			
 			// Verifica se foi escrito corretamente
 			const stats = statSync(agentPath);
-			Logger.debug(`Escrito: ${stats.size} bytes`);
+			if (stats.size < 1000) {
+				throw new Error(`Arquivo muito pequeno (${stats.size} bytes)`);
+			}
 			
-			Logger.success("HotswapAgent v2.0.3 installed globally!");
+			Logger.success(`HotswapAgent v${VERSIONS.HOTSWAP_AGENT.VERSION} instalado!`);
 			return agentPath;
 		} catch (e: any) {
-			Logger.warn(`Falha ao baixar HotswapAgent: ${e.message}`);
-			Logger.warn("Usando hot swap padrão da JVM.");
+			Logger.warn("Falha ao baixar HotswapAgent. Usando hot swap padrão da JVM.");
 			
 			// Limpa arquivo parcial se existir
 			if (existsSync(agentPath)) {
 				try {
 					await fs.unlink(agentPath);
-					Logger.debug("Arquivo parcial removido");
 				} catch {}
 			}
 			
@@ -331,7 +363,8 @@ export class TomcatService {
 						this.stopStartupSpinner(isSuccess);
 						this.stopStartupSpinner = undefined;
 					}
-					if (isSuccess && this.onReady) {
+					if (isSuccess && this.onReady && !this.hasReadyBeenCalled) {
+						this.hasReadyBeenCalled = true;
 						this.onReady();
 					}
 				}