@silasfmartins/testhub 1.0.0

package/dist/src/testhub/TestHubReporter.d.ts

@@ -0,0 +1,62 @@
+/**
+ * TestHubReporter: Reporter para enviar resultados para AutoCore Hub
+ *
+ * 🚀 ENDPOINTS UTILIZADOS:
+ * - POST /api/execucoes/batch (dados estruturados)
+ * - POST /api/execucoes/artifacts (binários em Base64)
+ *
+ * 📦 FONTE DE DADOS:
+ * - .rbqa/ct-execution-data.json (gerado pelo StatementTracker)
+ */
+export declare class TestHubReporter {
+    private client;
+    private systemsManager;
+    constructor();
+    /**
+     * 📤 Envia todos os resultados da suíte de testes em formato BATCH
+     * 🎯 USA DADOS DO ARQUIVO .rbqa/ct-execution-data.json como fonte de verdade
+     * 🚀 ENVIA PARA: POST /api/execucoes/batch + POST /api/execucoes/artifacts
+     */
+    sendAllResults(): Promise<void>;
+    /**
+     * ✅ Marca o envio como sucesso para garantir que o processo não termine antes
+     */
+    private markSendSuccess;
+    /**
+     * 📦 Compacta e envia artifacts (relatórios) para o AutoCore Hub
+     * 🚀 ENDPOINT: POST /api/execucoes/artifacts
+     */
+    private sendArtifacts;
+    /**
+     * 📖 Lê dados do arquivo .rbqa/ct-execution-data.json
+     */
+    private readCTExecutionData;
+    /**
+     * 📋 Obtém logs capturados do terminal
+     */
+    private getTerminalLogs;
+    /**
+     * 🌍 Detecta ambiente de execução (LOCAL ou AZURE)
+     */
+    private detectEnvironment;
+    /**
+     * Obtém matrícula do usuário (Azure: email, Local: USERNAME)
+     */
+    private getMatricula;
+    /**
+     * Testa conectividade com AutoCore Hub
+     */
+    testConnection(): Promise<boolean>;
+    /**
+     * 🆕 Constrói logs formatados de API a partir das executedActions
+     * Gera logs completos com REQUEST e RESPONSE (headers + body)
+     * Formato idêntico ao terminal para facilitar debug no TestHub
+     */
+    private buildApiLogsFromActions;
+    /**
+     * 🎯 Mapeia tipos de ação internos para tipos aceitos pelo Hub
+     * Backend aceita: "API"|"Database"|"Validation"|"Click"|"Fill"|"Navigate"
+     */
+    private mapActionTypeForHub;
+}
+export default TestHubReporter;

package/dist/src/testhub/TestHubReporter.js

@@ -0,0 +1,576 @@
+/**
+ * TestHubReporter: Reporter para enviar resultados para AutoCore Hub
+ *
+ * 🚀 ENDPOINTS UTILIZADOS:
+ * - POST /api/execucoes/batch (dados estruturados)
+ * - POST /api/execucoes/artifacts (binários em Base64)
+ *
+ * 📦 FONTE DE DADOS:
+ * - .rbqa/ct-execution-data.json (gerado pelo StatementTracker)
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { ArtifactsCompressor } from '../utils/ArtifactsCompressor.js';
+import SystemsManager from './SystemsManager.js';
+import TestHubClient from './TestHubClient.js';
+import { Logger } from '../utils/Logger.js';
+export class TestHubReporter {
+    client;
+    systemsManager;
+    constructor() {
+        this.client = TestHubClient.getInstance();
+        this.systemsManager = SystemsManager.getInstance();
+    }
+    /**
+     * 📤 Envia todos os resultados da suíte de testes em formato BATCH
+     * 🎯 USA DADOS DO ARQUIVO .rbqa/ct-execution-data.json como fonte de verdade
+     * 🚀 ENVIA PARA: POST /api/execucoes/batch + POST /api/execucoes/artifacts
+     */
+    async sendAllResults() {
+        try {
+            // 🎯 LER DADOS DO ARQUIVO JSON (fonte de verdade)
+            const ctExecutionData = this.readCTExecutionData();
+            if (!ctExecutionData ||
+                !ctExecutionData.tests ||
+                ctExecutionData.tests.length === 0) {
+                Logger.warning('\n⚠️ Nenhum dado de execução disponível para enviar');
+                return;
+            }
+            const allCTs = ctExecutionData.tests.flatMap((test) => test.cts);
+            const globalPassedCTs = allCTs.filter((ct) => ct.status === 'passed').length;
+            const globalFailedCTs = allCTs.filter((ct) => ct.status === 'failed' || ct.status === 'running').length;
+            // 🎯 Detectar ambiente de execução (LOCAL ou AZURE)
+            const ambiente = this.detectEnvironment();
+            Logger.info(`🌍 AMBIENTE: ${ambiente}`);
+            // 🎯 Obter sistema selecionado
+            const selectedSystem = this.systemsManager.getSelectedSystem();
+            const globalSystemName = selectedSystem?.system.name || 'Unknown';
+            Logger.info(`🎯 SISTEMA GLOBAL: ${globalSystemName}`);
+            // 📋 Obter logs capturados do terminal
+            const terminalLogs = this.getTerminalLogs();
+            // Montar payload batch completo conforme API do AutoCore Hub
+            // NOTA: matrícula e email agora são enviados via headers (x-automation-user-matricula e x-automation-user-email)
+            // 🔧 Calcular startTime e endTime do batch COM VALIDAÇÃO
+            // Normalizar startTime para milissegundos (number) para evitar concatenação de string
+            const rawStart = ctExecutionData.startTime || ctExecutionData.timestamp || Date.now();
+            const batchStartMs = typeof rawStart === 'number' ? rawStart : new Date(rawStart).getTime();
+            const batchStartTime = Number.isNaN(batchStartMs) ? Date.now() : batchStartMs;
+            // Calcular endTime: usar endTime direto se existir, senão somar duração ao start
+            const rawEnd = ctExecutionData.endTime;
+            let batchEndTime;
+            if (rawEnd) {
+                const parsedEnd = typeof rawEnd === 'number' ? rawEnd : new Date(rawEnd).getTime();
+                batchEndTime = Number.isNaN(parsedEnd) ? Date.now() : parsedEnd;
+            }
+            else {
+                batchEndTime = batchStartTime + (ctExecutionData.totalDuration || 0);
+            }
+            // 🛡️ VALIDAÇÃO: Verificar se os timestamps são válidos antes de converter para ISO
+            let batchStartTimeFormatted;
+            let batchEndTimeFormatted;
+            try {
+                const startDate = new Date(batchStartTime);
+                if (Number.isNaN(startDate.getTime())) {
+                    Logger.warning(`⚠️ [TestHubReporter] batchStartTime inválido: ${batchStartTime} (tipo: ${typeof batchStartTime})`);
+                    Logger.warning(`   📋 ctExecutionData.startTime: ${ctExecutionData.startTime}`);
+                    Logger.warning(`   📋 ctExecutionData.timestamp: ${ctExecutionData.timestamp}`);
+                    batchStartTimeFormatted = new Date().toISOString(); // Fallback para agora
+                }
+                else {
+                    batchStartTimeFormatted = ctExecutionData.startTimeFormatted || startDate.toISOString();
+                }
+            }
+            catch (err) {
+                Logger.warning(`⚠️ [TestHubReporter] Erro ao formatar batchStartTime: ${err}`);
+                Logger.warning(`   📋 Valor: ${batchStartTime} (tipo: ${typeof batchStartTime})`);
+                batchStartTimeFormatted = new Date().toISOString();
+            }
+            try {
+                const endDate = new Date(batchEndTime);
+                if (Number.isNaN(endDate.getTime())) {
+                    Logger.warning(`⚠️ [TestHubReporter] batchEndTime inválido: ${batchEndTime} (tipo: ${typeof batchEndTime})`);
+                    Logger.warning(`   📋 ctExecutionData.endTime: ${ctExecutionData.endTime}`);
+                    Logger.warning(`   📋 batchStartTime: ${batchStartTime}`);
+                    Logger.warning(`   📋 ctExecutionData.totalDuration: ${ctExecutionData.totalDuration}`);
+                    batchEndTimeFormatted = new Date().toISOString(); // Fallback para agora
+                }
+                else {
+                    batchEndTimeFormatted = ctExecutionData.endTimeFormatted || endDate.toISOString();
+                }
+            }
+            catch (err) {
+                Logger.warning(`⚠️ [TestHubReporter] Erro ao formatar batchEndTime: ${err}`);
+                Logger.warning(`   📋 Valor: ${batchEndTime} (tipo: ${typeof batchEndTime})`);
+                batchEndTimeFormatted = new Date().toISOString();
+            }
+            const batchPayload = {
+                ambiente, // ✅ LOCAL ou AZURE
+                systemName: globalSystemName, // ✅ Sistema global da execução
+                timestamp: ctExecutionData.timestamp,
+                startTime: batchStartTime, // ✅ NOVO: Início da execução
+                startTimeFormatted: batchStartTimeFormatted, // ✅ NOVO: Início formatado
+                endTime: batchEndTime, // ✅ NOVO: Fim da execução
+                endTimeFormatted: batchEndTimeFormatted, // ✅ NOVO: Fim formatado
+                totalCTs: allCTs.length,
+                passedCTs: globalPassedCTs, // ✅ CORRIGIDO: Recalculado
+                failedCTs: globalFailedCTs, // ✅ CORRIGIDO: Recalculado incluindo "running"
+                totalDuration: ctExecutionData.totalDuration,
+                totalDurationFormatted: ctExecutionData.totalDurationFormatted,
+                terminalLogs, // ✅ NOVO: Logs do terminal
+                tests: ctExecutionData.tests.map((testData, testIndex) => {
+                    Logger.info(`\n   📋 Teste ${testIndex + 1}/${ctExecutionData.tests.length}: "${testData.testName}"`);
+                    Logger.info(`      ⏱️ Duração: ${testData.durationFormatted}`);
+                    Logger.info(`      🧪 CTs: ${testData.cts.length} total`);
+                    // 🎯 Calcular contadores de CTs para cada teste (CN)
+                    // 🛡️ CRÍTICO: Converter "running" para "failed" nos contadores
+                    const testPassedCTs = testData.cts.filter((ct) => ct.status === 'passed').length;
+                    const testFailedCTs = testData.cts.filter((ct) => ct.status === 'failed' || ct.status === 'running').length;
+                    const testSkippedCTs = testData.cts.filter((ct) => ct.status === 'skipped').length;
+                    Logger.info(`      ✅ Passados: ${testPassedCTs}`);
+                    Logger.info(`      ❌ Falhados: ${testFailedCTs}`);
+                    Logger.info(`      ⏭️ Pulados: ${testSkippedCTs}`);
+                    // Listar CTs
+                    testData.cts.forEach((ct, ctIndex) => {
+                        const statusIcon = ct.status === 'passed'
+                            ? '✅'
+                            : ct.status === 'failed'
+                                ? '❌'
+                                : '⏭️';
+                        Logger.info(`      ${statusIcon} CT${ctIndex + 1}: "${ct.name}" (${ct.durationFormatted}) - Sistema: ${ct.systemName || 'Nenhum'}`);
+                        if (ct.error) {
+                            Logger.info(`         ⚠️ Erro: ${ct.error.substring(0, 80)}...`);
+                        }
+                    });
+                    // 📋 Obter logs específicos deste teste
+                    const testLogs = terminalLogs?.byTest?.[testData.testName] || [];
+                    Logger.info(`      📋 Logs deste teste: ${testLogs.length} logs`);
+                    // 🔧 Calcular startTime e endTime do teste com fallbacks
+                    const testStartTime = testData.startTime || Date.now();
+                    const testEndTime = testData.endTime || (testStartTime + (testData.duration || 0));
+                    const testStartTimeFormatted = testData.startTimeFormatted || new Date(testStartTime).toISOString();
+                    const testEndTimeFormatted = testData.endTimeFormatted || new Date(testEndTime).toISOString();
+                    return {
+                        testName: testData.testName,
+                        systemName: globalSystemName, // ✅ Sistema global para o teste (CN)
+                        startTime: testStartTime,
+                        startTimeFormatted: testStartTimeFormatted,
+                        endTime: testEndTime, // ✅ CORRIGIDO: Com fallback
+                        endTimeFormatted: testEndTimeFormatted, // ✅ CORRIGIDO: Com fallback
+                        totalCTs: testData.cts.length,
+                        passedCTs: testPassedCTs, // ✅ CORRIGIDO: Calculado dinamicamente
+                        failedCTs: testFailedCTs, // ✅ CORRIGIDO: Calculado dinamicamente
+                        skippedCTs: testSkippedCTs, // ✅ NOVO: CTs pulados
+                        duration: testData.duration || 0,
+                        durationFormatted: testData.durationFormatted || '0ms',
+                        logs: testLogs, // ✅ NOVO: Logs deste teste (texto completo)
+                        cts: testData.cts.map((ct) => {
+                            // 🛡️ VALIDAÇÃO: Se CT está "running" ao enviar para Hub, marcar como "failed"
+                            const finalStatus = ct.status === 'running' ? 'failed' : ct.status;
+                            const finalEndTime = ct.endTime || Date.now();
+                            const finalDuration = ct.duration || (finalEndTime - ct.startTime);
+                            // 🆕 AGREGAR executedActions do CT + de todos os Statements
+                            // As actions podem estar diretamente no CT OU dentro dos statements
+                            const ctDirectActions = ct.executedActions || [];
+                            const statementsActions = (ct.statements || []).flatMap((stmt) => stmt.executedActions || []);
+                            const allExecutedActions = [...ctDirectActions, ...statementsActions];
+                            // 🐛 DEBUG: Log para verificar agregação de actions
+                            const apiActionsCount = allExecutedActions.filter((a) => a.type === 'API').length;
+                            if (allExecutedActions.length > 0 || ct.statements?.length > 0) {
+                                Logger.info(`         📊 CT "${ct.name}": ${ctDirectActions.length} ações diretas + ${statementsActions.length} ações de statements = ${allExecutedActions.length} total (${apiActionsCount} API)`);
+                            }
+                            // 🆕 GERAR LOGS COMPLETOS DE API A PARTIR DE executedActions AGREGADOS
+                            const apiLogs = this.buildApiLogsFromActions(allExecutedActions);
+                            // 🆕 Combinar logs existentes + logs de API estruturados
+                            const combinedLogs = [
+                                ...(ct.logs || []),
+                                ...apiLogs,
+                            ];
+                            // 🆕 Simplificar executedActions para o Hub (remover dados grandes)
+                            // 🎯 Mapear tipos para valores aceitos pelo backend
+                            const simplifiedActions = allExecutedActions.map((action) => ({
+                                type: this.mapActionTypeForHub(action.type),
+                                description: action.description,
+                                timestamp: action.timestamp,
+                                duration: action.duration,
+                                success: action.success,
+                                // 🛡️ Enviar apenas resumo, não dados completos de headers/body
+                                details: action.details ? {
+                                    method: action.details.method,
+                                    url: action.details.url,
+                                    statusCode: action.details.statusCode,
+                                    // NÃO enviar requestHeaders, requestBody, responseHeaders, responseBody
+                                } : undefined,
+                            }));
+                            return {
+                                name: ct.name,
+                                systemName: ct.systemName, // ✅ CORRIGIDO: Só usar systemName se foi explicitamente definido por setSystem()
+                                status: finalStatus,
+                                startTime: ct.startTime,
+                                startTimeFormatted: ct.startTimeFormatted,
+                                endTime: finalEndTime,
+                                endTimeFormatted: ct.endTimeFormatted || new Date(finalEndTime).toISOString(),
+                                duration: finalDuration,
+                                durationFormatted: ct.durationFormatted || `${finalDuration}ms`,
+                                error: ct.error || (finalStatus === 'failed' && ct.status === 'running' ? 'CT não finalizado corretamente' : undefined),
+                                logs: combinedLogs, // 🆕 LOGS DO CT (texto + logs de API estruturados)
+                                executedActions: simplifiedActions, // 🆕 Ações simplificadas (sem dados grandes)
+                            };
+                        }),
+                    };
+                }),
+            };
+            Logger.info('\n📤 Enviando batch para AutoCore Hub...');
+            const executionIds = await this.client.sendBatchExecution(batchPayload);
+            if (executionIds && executionIds.length > 0) {
+                Logger.success('Batch enviado com sucesso!');
+                Logger.info(`   🆔 IDs das execuções: ${executionIds.join(', ')}`);
+                // ✅ CRÍTICO: Marcar envio como sucesso
+                this.markSendSuccess();
+            }
+            else {
+                Logger.warning('\n⚠️ Batch enviado mas nenhum ID retornado');
+            }
+            // ✅ CRÍTICO: Aguardar para garantir que a conexão HTTP foi finalizada
+            // No modo UI, o processo pode terminar antes do socket fechar
+            Logger.info('⏳ Aguardando finalização da conexão HTTP...');
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            // 📦 COMPACTAR E ENVIAR ARTIFACTS PARA /api/execucoes/artifacts
+            await this.sendArtifacts();
+            // ✅ CRÍTICO: Delay final para garantir que TUDO foi enviado
+            Logger.info('⏳ Garantindo que todos os dados foram transmitidos...');
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+            Logger.success('Transmissão de dados finalizada!');
+        }
+        catch (error) {
+            Logger.error('\n' + '='.repeat(80));
+            Logger.error('❌ ERRO AO ENVIAR RESULTADOS PARA AUTOCORE HUB');
+            Logger.error('='.repeat(80));
+            Logger.error(`📛 Mensagem: ${error.message}`);
+            // 🔧 LOG COMPLETO DA REQUISIÇÃO PARA DEBUG
+            if (error.requestUrl) {
+                Logger.error('');
+                Logger.error('📡 DETALHES DA REQUISIÇÃO:');
+                Logger.error('-'.repeat(80));
+                Logger.error(`🔗 URL: ${error.requestUrl}`);
+                Logger.error(`📋 Método: POST`);
+            }
+            if (error.requestHeaders) {
+                Logger.error('');
+                Logger.error('📨 HEADERS ENVIADOS:');
+                Logger.error('-'.repeat(80));
+                // Mascarar x-automation-key para segurança
+                const safeHeaders = { ...error.requestHeaders };
+                if (safeHeaders['x-automation-key']) {
+                    safeHeaders['x-automation-key'] = safeHeaders['x-automation-key'].substring(0, 8) + '...[MASKED]';
+                }
+                Logger.error(JSON.stringify(safeHeaders, null, 2));
+            }
+            if (error.requestBody) {
+                Logger.error('');
+                Logger.error('📦 BODY ENVIADO (primeiros 5000 caracteres):');
+                Logger.error('-'.repeat(80));
+                const bodyPreview = error.requestBody.length > 5000
+                    ? error.requestBody.substring(0, 5000) + '\n... [TRUNCADO - Total: ' + error.requestBody.length + ' caracteres]'
+                    : error.requestBody;
+                try {
+                    // Tenta formatar como JSON para melhor leitura
+                    const parsed = JSON.parse(error.requestBody);
+                    Logger.error(JSON.stringify(parsed, null, 2).substring(0, 5000));
+                }
+                catch {
+                    Logger.error(bodyPreview);
+                }
+            }
+            if (error.responseText) {
+                Logger.error('');
+                Logger.error('📥 RESPOSTA DO SERVIDOR:');
+                Logger.error('-'.repeat(80));
+                Logger.error(error.responseText);
+            }
+            if (error.status) {
+                Logger.error('');
+                Logger.error(`🔴 HTTP Status: ${error.status} ${error.statusText || ''}`);
+            }
+            Logger.error('');
+            Logger.error('📍 STACK TRACE:');
+            Logger.error('-'.repeat(80));
+            Logger.error(error.stack);
+            Logger.error('='.repeat(80) + '\n');
+        }
+    }
+    /**
+     * ✅ Marca o envio como sucesso para garantir que o processo não termine antes
+     */
+    markSendSuccess() {
+        try {
+            const successPath = path.join(process.cwd(), '.rbqa', 'hub-send-success.json');
+            const successData = {
+                timestamp: new Date().toISOString(),
+                success: true,
+            };
+            fs.writeFileSync(successPath, JSON.stringify(successData, null, 2));
+        }
+        catch {
+            // Ignorar erro ao salvar marcador
+        }
+    }
+    /**
+     * 📦 Compacta e envia artifacts (relatórios) para o AutoCore Hub
+     * 🚀 ENDPOINT: POST /api/execucoes/artifacts
+     */
+    async sendArtifacts() {
+        try {
+            const compressor = new ArtifactsCompressor(process.cwd());
+            const artifacts = await compressor.compressAllArtifacts();
+            // Verificar se há artifacts para enviar
+            if (!artifacts.htmlReport &&
+                !artifacts.testResults &&
+                artifacts.traces?.length === 0 &&
+                artifacts.screenshots?.length === 0) {
+                Logger.warning('⚠️ Nenhum artifact encontrado para enviar');
+                return;
+            }
+            // Montar payload dos artifacts
+            // NOTA: matrícula e email agora são enviados via headers (x-automation-user-matricula e x-automation-user-email)
+            const payload = {
+                timestamp: new Date().toISOString(),
+                artifacts: {
+                    htmlReport: artifacts.htmlReport,
+                    testResults: artifacts.testResults,
+                    traces: artifacts.traces,
+                    screenshots: artifacts.screenshots,
+                    size: artifacts.size,
+                },
+            };
+            // 🚀 ENVIAR PARA /api/execucoes/artifacts
+            Logger.info('📦 Enviando artifacts para AutoCore Hub...');
+            await this.client.sendArtifacts(payload);
+            Logger.success('Artifacts enviados com sucesso!');
+            // ✅ CRÍTICO: Aguardar para garantir que o upload foi completado
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+        catch (error) {
+            Logger.error(`❌ Erro ao enviar artifacts: ${error.message}`);
+            Logger.warning('⚠️ Continuando execução sem artifacts...');
+        }
+    }
+    /**
+     * 📖 Lê dados do arquivo .rbqa/ct-execution-data.json
+     */
+    readCTExecutionData() {
+        try {
+            const jsonPath = path.join(process.cwd(), '.rbqa', 'ct-execution-data.json');
+            if (!fs.existsSync(jsonPath)) {
+                Logger.warning(`⚠️ Arquivo não encontrado: ${jsonPath}`);
+                return null;
+            }
+            const jsonContent = fs.readFileSync(jsonPath, 'utf-8');
+            const data = JSON.parse(jsonContent);
+            return data;
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao ler ct-execution-data.json', error);
+            return null;
+        }
+    }
+    /**
+     * 📋 Obtém logs capturados do terminal
+     */
+    getTerminalLogs() {
+        try {
+            // Tentar obter logs do TerminalLogCapture
+            if (globalThis.TerminalLogCapture) {
+                const logCapture = globalThis.TerminalLogCapture;
+                const logsByTest = logCapture.getLogsByTest();
+                const stats = logCapture.getStats();
+                Logger.info(`📋 Logs capturados: ${stats.totalLogs} total`);
+                Logger.info(`📊 Logs por nível: ${stats.byLevel.log} log, ${stats.byLevel.info} info, ${stats.byLevel.warn} warn, ${stats.byLevel.error} error`);
+                // Converter Map para objeto simples
+                const logsObject = {};
+                for (const [testName, logs] of logsByTest.entries()) {
+                    logsObject[testName] = logs;
+                }
+                return {
+                    totalLogs: stats.totalLogs,
+                    byLevel: stats.byLevel,
+                    byTest: logsObject,
+                    stats,
+                };
+            }
+            // Tentar ler do arquivo salvo
+            const logsPath = path.join(process.cwd(), 'test-results', 'terminal-logs.json');
+            if (fs.existsSync(logsPath)) {
+                const logsContent = fs.readFileSync(logsPath, 'utf-8');
+                const logsData = JSON.parse(logsContent);
+                Logger.info(`📋 Logs lidos do arquivo: ${logsData.totalLogs} total`);
+                return logsData;
+            }
+            Logger.warning('⚠️ Nenhum log do terminal encontrado');
+            return null;
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao obter logs do terminal', error);
+            return null;
+        }
+    }
+    /**
+     * 🌍 Detecta ambiente de execução (LOCAL ou AZURE)
+     */
+    detectEnvironment() {
+        // Verificar se está rodando no Azure Pipeline
+        const isAzurePipeline = !!(process.env.BUILD_REQUESTEDFOREMAIL ||
+            process.env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI ||
+            process.env.AGENT_NAME ||
+            process.env.BUILD_BUILDID);
+        if (isAzurePipeline) {
+            Logger.info('🔵 Ambiente detectado: AZURE Pipeline');
+            return 'AZURE';
+        }
+        Logger.info('💻 Ambiente detectado: LOCAL');
+        return 'LOCAL';
+    }
+    /**
+     * Obtém matrícula do usuário (Azure: email, Local: USERNAME)
+     */
+    getMatricula() {
+        // Azure Pipeline - usar email se disponível
+        const azureEmail = process.env.BUILD_REQUESTEDFOREMAIL;
+        if (azureEmail) {
+            Logger.info(`🔵 Azure Pipeline - Email: ${azureEmail}`);
+            // Extrair matrícula do email se possível
+            const matriculaMatch = azureEmail.match(/A\d{7}/);
+            if (matriculaMatch) {
+                Logger.info(`🎯 Matrícula extraída: ${matriculaMatch[0]}`);
+                return matriculaMatch[0];
+            }
+            return azureEmail;
+        }
+        // Local - usar matrícula configurada ou USERNAME
+        return (process.env.AUTOCORE_USER_MATRICULA ||
+            process.env.USERNAME ||
+            process.env.USER ||
+            'N/A');
+    }
+    /**
+     * Testa conectividade com AutoCore Hub
+     */
+    async testConnection() {
+        return await this.client.testConnection();
+    }
+    /**
+     * 🆕 Constrói logs formatados de API a partir das executedActions
+     * Gera logs completos com REQUEST e RESPONSE (headers + body)
+     * Formato idêntico ao terminal para facilitar debug no TestHub
+     */
+    buildApiLogsFromActions(executedActions) {
+        if (!executedActions || executedActions.length === 0) {
+            return [];
+        }
+        const apiLogs = [];
+        for (const action of executedActions) {
+            // Só processar ações de API que tenham detalhes completos
+            if (action.type !== 'API' || !action.details) {
+                continue;
+            }
+            const details = action.details;
+            const statusIcon = action.success ? '✅' : '❌';
+            const statusText = action.success ? 'PASSED' : 'FAILED';
+            // Header do log
+            apiLogs.push('');
+            apiLogs.push('═'.repeat(70));
+            apiLogs.push(`${statusIcon} API CALL: ${action.description} [${statusText}]`);
+            apiLogs.push(`⏱️ Duração: ${action.duration || 0}ms | 🕐 ${action.timestamp}`);
+            apiLogs.push('═'.repeat(70));
+            // REQUEST - Formato completo
+            if (details.method && details.url) {
+                apiLogs.push('');
+                apiLogs.push('╔══════════════════════ REQUEST ═══════════════════════╗');
+                apiLogs.push(`║ ENDPOINT: ${details.url}`);
+                apiLogs.push(`║ METHOD: ${details.method}`);
+                // Request Headers - formato [key : value]
+                if (details.requestHeaders && typeof details.requestHeaders === 'object' && Object.keys(details.requestHeaders).length > 0) {
+                    const headersList = Object.entries(details.requestHeaders)
+                        .map(([key, value]) => `[${key} : ${value}]`)
+                        .join(' ');
+                    apiLogs.push(`║ HEADERS: ${headersList}`);
+                }
+                else {
+                    apiLogs.push(`║ HEADERS: [nenhum]`);
+                }
+                // Request Body
+                const reqBody = details.requestBody;
+                if (reqBody && typeof reqBody === 'string' && reqBody.trim()) {
+                    apiLogs.push(`║ BODY:`);
+                    // Dividir body em linhas para formatação
+                    const bodyLines = reqBody.split('\n');
+                    for (const line of bodyLines) {
+                        apiLogs.push(`║   ${line}`);
+                    }
+                }
+                else {
+                    apiLogs.push(`║ BODY: [vazio]`);
+                }
+                apiLogs.push('╚═══════════════════════════════════════════════════════╝');
+            }
+            // RESPONSE - Formato completo
+            if (details.statusCode !== undefined) {
+                apiLogs.push('');
+                apiLogs.push('╔══════════════════════ RESPONSE ══════════════════════╗');
+                const statusCodeIcon = details.statusCode >= 200 && details.statusCode < 300 ? '✅' : '⚠️';
+                apiLogs.push(`║ ${statusCodeIcon} STATUS CODE: ${details.statusCode}`);
+                // Response Headers - formato [key : value]
+                if (details.responseHeaders && typeof details.responseHeaders === 'object' && Object.keys(details.responseHeaders).length > 0) {
+                    const headersList = Object.entries(details.responseHeaders)
+                        .map(([key, value]) => `[${key} : ${value}]`)
+                        .join(' ');
+                    apiLogs.push(`║ HEADERS: ${headersList}`);
+                }
+                else {
+                    apiLogs.push(`║ HEADERS: [nenhum]`);
+                }
+                // Response Body
+                const respBody = details.responseBody;
+                if (respBody && typeof respBody === 'string' && respBody.trim()) {
+                    apiLogs.push(`║ BODY:`);
+                    // Dividir body em linhas para formatação
+                    const bodyLines = respBody.split('\n');
+                    for (const line of bodyLines) {
+                        apiLogs.push(`║   ${line}`);
+                    }
+                }
+                else {
+                    apiLogs.push(`║ BODY: [vazio]`);
+                }
+                apiLogs.push('╚═══════════════════════════════════════════════════════╝');
+            }
+            apiLogs.push('');
+        }
+        // Log de debug para verificar quantas ações de API foram processadas
+        const apiActionsCount = executedActions.filter(a => a.type === 'API').length;
+        if (apiActionsCount > 0) {
+            apiLogs.unshift(`📊 Total de chamadas API capturadas: ${apiActionsCount}`);
+            apiLogs.unshift('');
+        }
+        return apiLogs;
+    }
+    /**
+     * 🎯 Mapeia tipos de ação internos para tipos aceitos pelo Hub
+     * Backend aceita: "API"|"Database"|"Validation"|"Click"|"Fill"|"Navigate"
+     */
+    mapActionTypeForHub(type) {
+        const typeMapping = {
+            'API': 'API',
+            'DB': 'Database',
+            'SSH': 'API', // SSH é tratado como API no Hub
+            'UI': 'Click', // Ações de UI genéricas mapeiam para Click
+            'MOBILE': 'Click', // Mobile também mapeia para Click
+            'OTHER': 'Validation', // Outros mapeiam para Validation
+            'VALIDATION': 'Validation',
+            'CLICK': 'Click',
+            'FILL': 'Fill',
+            'NAVIGATE': 'Navigate',
+        };
+        return typeMapping[type?.toUpperCase()] || 'Validation';
+    }
+}
+export default TestHubReporter;