@silasfmartins/testhub 1.0.0

package/dist/src/utils/UnifiedTeardown.js

@@ -0,0 +1,400 @@
+import fs from 'node:fs';
+import path from 'path';
+import { ApiActions } from '../api/ApiActions.js';
+import { MobileConnection } from '../appium/MobileConnection.js';
+import { cleanupEnvLock } from '../config/envLoader.js';
+import { BancoActions } from '../helpers/BancoActions.js';
+import { saveReport, sendReportToOctane } from '../octane/OctaneReporter.js';
+import { SSHActions } from '../ssh/SSHActions.js';
+import { SSHClient } from '../ssh/SSHClient.js';
+import { TestContext } from '../testContext/TestContext.js';
+import { UnifiedReportManager } from '../testContext/UnifiedReportManager.js';
+import { ConfigLogger } from './ConfigLogger.js';
+import { DataStore } from './DataStore.js';
+import { Logger } from './Logger.js';
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+import { EvidenceReportGenerator } from './EvidenceReportGenerator.js';
+import TestHubReporter from '../testhub/TestHubReporter.js';
+import { teamsFlushAfterExecution } from './TeamsFlushHook.js';
+// 🔒 Flag para controlar se o envio para o Hub foi completado
+let hubSendCompleted = false;
+// Utilitário para log estilo Java
+function javaStyleLog(context, message, level = 'INFO') {
+    const now = new Date();
+    const date = now
+        .toLocaleDateString('en-US', {
+        month: 'short',
+        day: '2-digit',
+        year: 'numeric',
+    })
+        .replace(',', '');
+    const time = now.toLocaleTimeString('en-US', { hour12: true });
+    // Exemplo: jul 08, 2025 9:45:44 AM OctaneManager
+    Logger.info(`${date} ${time} ${context}\n${level}: ${message}`);
+}
+export class UnifiedTeardown {
+    static async run() {
+        Logger.info('🏁 Iniciando teardown global...');
+        const projectType = process.env.PROJECT_TYPE || 'Desconhecido';
+        try {
+            // 📋 CRÍTICO: Salvar logs do terminal ANTES de finalizar
+            Logger.info('📋 Salvando logs do terminal...');
+            try {
+                if (globalThis.TerminalLogCapture) {
+                    const logCapture = globalThis.TerminalLogCapture;
+                    logCapture.saveToFile();
+                    const stats = logCapture.getStats();
+                    Logger.success(`Logs salvos: ${stats.totalLogs} total, ${stats.testsWithLogs} teste(s) com logs`);
+                }
+            }
+            catch (error) {
+                Logger.warning(`⚠️ Erro ao salvar logs do terminal: ${error}`);
+            }
+            // 🆕 CRÍTICO: Apenas salvar dados finais - CustomReporter já finalizou os CTs
+            Logger.info('🏁 Finalizando captura de CTs...');
+            try {
+                // ✅ Apenas salvar - NÃO refinalizar CTs que já foram finalizados pelo CustomReporter
+                await StatementTracker.finalize();
+                Logger.success('StatementTracker finalizado com sucesso');
+            }
+            catch (error) {
+                Logger.warning(`⚠️ Erro ao finalizar StatementTracker: ${error}`);
+            }
+            // ✅ APENAS FINALIZAR MÉTRICAS se ainda não foi finalizado
+            Logger.info('📊 Finalizando sistema de relatórios unificado...');
+            UnifiedReportManager.registrarFimExecucao();
+            const metrics = UnifiedReportManager.getMetrics();
+            if (metrics.totalTestes > 0) {
+                Logger.info(`📋 Execução concluída: ${metrics.totalTestes} teste(s)`);
+                // ✅ NOVO: Gerar relatório geral unificado
+                Logger.info('📄 Gerando relatório geral unificado...');
+                await UnifiedReportManager.anexarRelatorioGeral();
+                await EvidenceReportGenerator.generateEvidenceReport();
+            }
+            else {
+                Logger.info('ℹ️ Nenhum teste registrado');
+            }
+            // 🌐 Enviar resultados para AutoCore Hub
+            try {
+                Logger.info('🌐 Enviando resultados para AutoCore Hub...');
+                const reporter = new TestHubReporter();
+                // Enviar todos os resultados coletados em formato batch
+                await reporter.sendAllResults();
+                // ✅ CRÍTICO: Marcar envio como completado
+                hubSendCompleted = true;
+                // ✅ CRÍTICO: Aguardar para garantir que o envio HTTP foi completado
+                // Isso é especialmente importante no modo UI onde o processo pode terminar rapidamente
+                Logger.info('⏳ Aguardando confirmação de envio para o Hub...');
+                await new Promise((resolve) => setTimeout(resolve, 3000));
+                Logger.success('Envio para AutoCore Hub confirmado!');
+            }
+            catch (error) {
+                Logger.warning(`⚠️ Erro ao enviar resultados para AutoCore Hub: ${error}`);
+                Logger.warning('   Os testes foram executados normalmente, mas o envio falhou');
+                Logger.warning('   Verifique a conectividade com o backend AutoCore Hub');
+            }
+            // Envio para Octane/ALM se habilitado e variáveis obrigatórias presentes
+            if (process.env.ALM_ENABLE === 'true') {
+                const almHost = process.env.ALM_HOST;
+                const almDomain = process.env.ALM_DOMAIN;
+                const almProject = process.env.ALM_PROJECT;
+                const user = process.env.USER;
+                const password = process.env.PASSWORD;
+                const almTestRootPath = process.env.ALM_TEST_ROOT_PATH || '';
+                // Log estilo Java
+                Logger.info('########################################');
+                Logger.info('#');
+                Logger.info('#');
+                javaStyleLog('OctaneManager', 'INICIANDO API DO OCTANE');
+                Logger.info('#');
+                Logger.info('#');
+                Logger.info('########################################');
+                javaStyleLog('OctaneManager', `SERVER OCTANE: https://${almHost}`);
+                javaStyleLog('OctaneManager', `SHAREDSPACE OCTANE: ${almDomain}`);
+                javaStyleLog('OctaneManager', `WORKSPACE OCTANE: ${almProject}`);
+                if (almHost && almDomain && almProject && user && password) {
+                    try {
+                        javaStyleLog('OctaneManager', '[SUCCESS] Informações de conexão capturadas');
+                        const octaneUrl = `https://${almHost}/api/shared_spaces/${almDomain}/workspaces/${encodeURIComponent(almProject)}/test-results${almTestRootPath ? `?rootPath=${encodeURIComponent(almTestRootPath)}` : ''}`;
+                        saveReport();
+                        const decodedPassword = Buffer.from(password, 'base64').toString('utf-8');
+                        await sendReportToOctane(octaneUrl, user, decodedPassword);
+                        javaStyleLog('OctaneManager', '[SUCCESS] Relatório enviado ao Octane/ALM');
+                    }
+                    catch (error) {
+                        javaStyleLog('OctaneManager', '[ERROR] Ocorreu um erro ao gerar o relatório', 'ERROR');
+                        if (error instanceof Error) {
+                            javaStyleLog('OctaneManager', error.stack || error.message, 'ERROR');
+                        }
+                        else {
+                            javaStyleLog('OctaneManager', String(error), 'ERROR');
+                        }
+                        javaStyleLog('OctaneManager', `❌ Falha ao enviar relatório ao Octane/ALM: ${String(error)}`, 'ERROR');
+                    }
+                }
+                else {
+                    javaStyleLog('OctaneManager', '⚠️  Variáveis de ambiente obrigatórias para ALM/Octane não preenchidas. Envio não realizado.', 'ERROR');
+                }
+            }
+            else {
+                javaStyleLog('controllers.OctaneManager', 'Integração ALM/Octane desabilitada (ALM_ENABLE=false)');
+            }
+            await projectSpecificCleanup(projectType);
+            await globalCleanup();
+        }
+        catch (error) {
+            javaStyleLog('controllers.OctaneManager', `❌ Erro durante teardown global: ${String(error)}`, 'ERROR');
+        }
+        finally {
+            // 📨 Teams relay flush obrigatório no fim de cada execução (v2.7.44 - item 13)
+            // Sempre roda em finally (passou/falhou) para garantir envio de notificações
+            try {
+                await teamsFlushAfterExecution(50);
+            }
+            catch (flushErr) {
+                Logger.warning(`[UnifiedTeardown] ⚠️ Teams flush falhou: ${String(flushErr)}`);
+            }
+        }
+    }
+}
+async function projectSpecificCleanup(projectType) {
+    switch (projectType) {
+        case 'Mobile':
+            await cleanupMobile();
+            break;
+        case 'API':
+            await cleanupAPI();
+            break;
+        case 'Frontend':
+            await cleanupFrontend();
+            break;
+        case 'SSH':
+            await cleanupSSH();
+            break;
+        case 'Banco':
+            await cleanupBanco();
+            break;
+        case 'Mixed':
+            await cleanupMixed();
+            break;
+        case 'Cenários':
+            await cleanupCenarios();
+            break;
+        default:
+            await cleanupGeneric();
+    }
+}
+async function cleanupMobile() {
+    try {
+        await MobileConnection.closeSession();
+    }
+    catch (error) {
+        Logger.warning(`Erro ao fechar sessão mobile: ${String(error)}`);
+    }
+    try {
+        const hasActiveSession = TestContext.appiumDriver;
+        if (hasActiveSession) {
+            Logger.info('📱 Detectada sessão mobile ativa, finalizando...');
+            await Promise.race([
+                TestContext.resetAppiumDriver(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout na limpeza mobile')), 10_000)),
+            ]);
+            await MobileConnection.closeSession();
+            Logger.success('Sessão mobile finalizada no teardown global');
+        }
+        Object.keys(global).forEach((key) => {
+            if (key.startsWith('mobileCleanup_') ||
+                key.startsWith('updateActivity_')) {
+                delete global[key];
+            }
+        });
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro ou timeout na limpeza mobile: ${String(error)}`);
+        // Forçar encerramento da sessão caso falhe
+        try {
+            await MobileConnection.closeSession();
+        }
+        catch (forceError) {
+            Logger.warning(`⚠️ Erro na limpeza forçada mobile: ${String(forceError)}`);
+        }
+        try {
+            TestContext.forceCleanup();
+        }
+        catch (forceError) {
+            Logger.warning(`⚠️ Erro na limpeza forçada mobile: ${String(forceError)}`);
+        }
+    }
+}
+async function cleanupAPI() {
+    try {
+        const metrics = ApiActions.getMetrics();
+        const hasActivity = metrics.totalRequisicoes > 0 ||
+            Object.keys(metrics.logsPerTest || {}).length > 0;
+        if (hasActivity) {
+            Logger.info('📊 Processando relatórios de API...');
+            await Promise.race([
+                (async () => {
+                    ApiActions.registrarFimExecucao();
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                })(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout nos relatórios API')), 15_000)),
+            ]);
+        }
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro ao processar contextos API: ${String(error)}`);
+    }
+}
+async function cleanupFrontend() {
+    try {
+        await TestContext.finalizeAll();
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro na limpeza Frontend: ${String(error)}`);
+    }
+}
+async function cleanupSSH() {
+    try {
+        Logger.info('🔌 Limpeza SSH iniciada...');
+        // Desconectar via SSHActions (método principal)
+        if (SSHActions.foiUtilizado()) {
+            Logger.info('🔌 SSH foi utilizado, desconectando...');
+            await SSHActions.desconectar();
+            SSHActions.registrarFimExecucao();
+            Logger.success('SSH desconectado com sucesso');
+        }
+        else {
+            Logger.info('ℹ️  SSH não foi utilizado');
+        }
+        // Garantir desconexão de qualquer SSHClient restante
+        await SSHClient.disconnectAll();
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro na limpeza SSH: ${String(error)}`);
+    }
+}
+async function cleanupBanco() {
+    try {
+        if (BancoActions.foiUtilizado()) {
+            BancoActions.registrarFimExecucao();
+        }
+        else {
+            Logger.info('ℹ️  Banco não foi utilizado');
+        }
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro na limpeza Banco: ${String(error)}`);
+    }
+}
+async function cleanupMixed() {
+    const cleanupTasks = [
+        cleanupAPI(),
+        cleanupFrontend(),
+        cleanupSSH(),
+        cleanupBanco(),
+    ];
+    if (process.env.USE_MOBILE === 'true') {
+        cleanupTasks.push(cleanupMobile());
+    }
+    try {
+        await Promise.allSettled(cleanupTasks);
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro na limpeza Mixed: ${String(error)}`);
+    }
+}
+async function cleanupCenarios() {
+    try {
+        await TestContext.finalizeAll();
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro na limpeza Cenários: ${String(error)}`);
+    }
+}
+async function cleanupGeneric() {
+    try {
+        await TestContext.finalizeAll();
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro na limpeza genérica: ${String(error)}`);
+    }
+}
+async function globalCleanup() {
+    try {
+        await ConfigLogger.cleanup();
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro ao limpar ConfigLogger: ${String(error)}`);
+    }
+    try {
+        cleanupEnvLock();
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro ao limpar env locks: ${String(error)}`);
+    }
+    try {
+        DataStore.cleanup();
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro ao limpar DataStore: ${String(error)}`);
+    }
+    try {
+        const tempFiles = [
+            '.test-data-store.json',
+            '.env.lock',
+            '.configlogger.lock',
+            '.autocore/xpaths.generated.ts',
+        ];
+        // ✅ ATUALIZADO: Remover .rbqa da limpeza automática
+        // Preservar para o usuário acessar execution-data.json
+        const tempDirs = [
+        // '.rbqa'  // ❌ REMOVIDO: Manter dados para usuário acessar
+        ];
+        let cleanedFiles = 0;
+        for (const file of tempFiles) {
+            const filePath = path.resolve(process.cwd(), file);
+            if (fs.existsSync(filePath)) {
+                try {
+                    fs.unlinkSync(filePath);
+                    cleanedFiles++;
+                }
+                catch {
+                    // Ignorar erros de arquivos individuais
+                }
+            }
+        }
+        // ✅ NOVO: Limpeza de diretórios temporários
+        let cleanedDirs = 0;
+        for (const dir of tempDirs) {
+            const dirPath = path.resolve(process.cwd(), dir);
+            if (fs.existsSync(dirPath)) {
+                try {
+                    fs.rmSync(dirPath, { recursive: true, force: true });
+                    cleanedDirs++;
+                    Logger.success(`Pasta ${dir} removida com sucesso (final da execução)`);
+                }
+                catch (error) {
+                    Logger.warning(`⚠️ Erro ao remover pasta ${dir}: ${String(error)}`);
+                }
+            }
+        }
+        if (cleanedFiles > 0 || cleanedDirs > 0) {
+            Logger.info(`🧹 Limpeza final: ${cleanedFiles} arquivo(s) e ${cleanedDirs} pasta(s) removidos`);
+        }
+    }
+    catch (error) {
+        Logger.warning(`⚠️ Erro na limpeza de arquivos temporários: ${String(error)}`);
+    }
+}
+// 🆕 Exportação padrão para uso como globalTeardown do Playwright
+export default async function playwrightTeardown() {
+    await UnifiedTeardown.run();
+    // ✅ CRÍTICO: Garantir que o processo não termine antes do envio
+    // Isso é especialmente importante no modo UI onde o Playwright pode terminar rapidamente
+    if (!hubSendCompleted) {
+        Logger.info('⏳ Aguardando finalização de operações pendentes...');
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+    }
+    Logger.info('🏁 Teardown global finalizado!');
+}

package/dist/src/utils/XPathCatalog.d.ts

@@ -0,0 +1,152 @@
+/**
+ * XPath Catalog (v2.7.44 - items 17, 18, 19 & 21)
+ *
+ * Mantém catálogo de XPaths por página, atualizado via `extract_page_structure`,
+ * e oferece resolução inteligente para métodos de ação (click, fill, select…).
+ *
+ * Item 17 — `extractPageStructure` como base para catálogo
+ * Item 18 — `getCurrentXPathCatalog` + resolver interno
+ * Item 19 — Geração de `.autocore/xpaths.generated.ts` para IntelliSense
+ * Item 21 — `pushToBackend` para execuções Azure sem agente de IA
+ */
+export interface XPathCatalogItem {
+    xpath: string;
+    tag?: string;
+    text?: string;
+    id?: string;
+    name?: string;
+    placeholder?: string;
+    ariaLabel?: string;
+    title?: string;
+    role?: string;
+    className?: string;
+    dataTestId?: string;
+    type?: string;
+    href?: string;
+    /** Score de relevância (quanto maior, melhor match) */
+    score?: number;
+}
+export interface CatalogGetOptions {
+    /** URL / página alvo. Sem informar usa currentPageUrl. */
+    page?: string;
+    /** Filtro de texto livre (ex: "catalogo de ofertas"). */
+    filter?: string;
+    /** Se true, força recarregar a estrutura da página. */
+    refresh?: boolean;
+    /** default true — usar somente XPaths desta página */
+    strictPage?: boolean;
+    /** Máximo de itens retornados */
+    maxItems?: number;
+}
+/** Formato do retorno bruto da estrutura de página (MCP / extractBasicPageStructure) */
+export interface RawPageStructure {
+    title?: string;
+    url?: string;
+    buttons?: XPathCatalogItem[];
+    inputs?: XPathCatalogItem[];
+    links?: XPathCatalogItem[];
+    headings?: XPathCatalogItem[];
+    elements?: XPathCatalogItem[];
+}
+/** Payload enviado pelo framework ao backend quando MCP não está disponível */
+export interface CatalogExtractRequest {
+    url: string;
+    pageHtml?: string;
+    pageStructure?: RawPageStructure;
+    filter?: string;
+    strictPage?: boolean;
+    xpaths?: string[];
+    /** Nome do arquivo Page Object (item 21 v2.7.44) */
+    pageFileName?: string;
+    /** Nome legível da página (item 21 v2.7.44) */
+    pageName?: string;
+    /** Nome da classe Page Object (item 21 v2.7.44) */
+    pageObjectName?: string;
+    /** Contexto de sessão (item 21 v2.7.44) */
+    context?: {
+        currentUrl?: string;
+        sessionId?: string;
+    };
+    /** Estado de runtime capturado (item 21 v2.7.44) */
+    runtimeState?: {
+        cookies?: unknown[];
+        localStorage?: Record<string, string>;
+        sessionStorage?: Record<string, string>;
+    };
+}
+/** Resposta do backend para push de DOM */
+export interface CatalogExtractResponse {
+    success: boolean;
+    catalog?: XPathCatalogItem[];
+    xpaths?: string[];
+    error?: string;
+}
+/**
+ * Função que extrai a estrutura da página atual.
+ * Deve retornar `RawPageStructure` (format idêntico ao MCP extract_page_structure).
+ */
+export type PageStructureExtractor = (pageUrl?: string) => Promise<RawPageStructure>;
+export declare class XPathCatalog {
+    /** Injeta extrator de estrutura de página (obrigatório antes de usar) */
+    static setExtractor(fn: PageStructureExtractor): void;
+    /**
+     * Obtém catálogo de XPaths para a página fornecida (ou a página atual).
+     *
+     * @param currentPageUrl URL da página atual (usada quando opts.page não informado)
+     * @param opts Opções de consulta
+     */
+    static getCatalog(currentPageUrl: string, opts?: CatalogGetOptions): Promise<XPathCatalogItem[]>;
+    /**
+     * Recarrega a estrutura da página e atualiza o cache.
+     */
+    static refresh(pageUrl: string): Promise<XPathCatalogItem[]>;
+    /**
+     * Resolve um alvo (texto/xpath/id/name/placeholder) para o melhor XPath do catálogo.
+     * Retorna undefined se não encontrar match aceitável.
+     */
+    static resolveFromCatalog(target: string, pageUrl: string): string | undefined;
+    /** Limpa cache de uma página específica ou todo o cache */
+    static clearCache(pageUrl?: string): void;
+    /**
+     * Envia DOM/pageStructure capturado localmente para o backend processar.
+     *
+     * Usado em execuções Azure/CI onde o backend **não** tem acesso de rede
+     * à página alvo. O framework captura `pageHtml` e/ou `pageStructure`
+     * e envia para `POST /api/xpath-catalog/extract`.
+     *
+     * O backend enriquece com hints Redis e retorna catálogo + xpaths.
+     * O resultado alimenta o cache local por página.
+     *
+     * @param request Payload com URL, pageHtml/pageStructure e filtro opcional
+     * @param authToken JWT ou chave de automação (header Authorization)
+     * @returns Resposta do backend com catálogo enriquecido
+     *
+     * @example
+     * ```ts
+     * const html = await page.content()
+     * const result = await XPathCatalog.pushToBackend({
+     *   url: page.url(),
+     *   pageHtml: html,
+     *   filter: 'cliente',
+     * })
+     * if (result?.catalog) {
+     *   // catálogo já está no cache; usar via getCatalog()
+     * }
+     * ```
+     */
+    static pushToBackend(request: CatalogExtractRequest, authToken?: string): Promise<CatalogExtractResponse | null>;
+    /**
+     * Gera arquivo `.autocore/xpaths.generated.ts` com constantes tipadas por tela.
+     *
+     * @param outputDir Diretório de saída (default: `.autocore` na raiz do projeto)
+     */
+    static generateIntelliSenseFile(outputDir?: string): void;
+    /** Converte estrutura bruta em lista flat de XPathCatalogItem */
+    private static flatten;
+    /** Aplica filtro textual e ordena por relevância */
+    private static applyFilter;
+    /** Converte pageKey em nome de constante TypeScript */
+    private static pageKeyToConstName;
+    /** Converte item em nome de propriedade para IntelliSense */
+    private static itemToPropName;
+}