@silasfmartins/testhub 1.0.0

package/dist/src/testhub/TestHubClient.js

@@ -0,0 +1,1215 @@
+/**
+ * TestHubClient: Cliente HTTP para comunicação com o backend TestHub
+ * Responsável por buscar sistemas e enviar resultados de execução
+ *
+ * NOTA: Usa fetch nativo do Node.js (sem axios) para evitar problemas com proxy corporativo
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { Logger } from '../utils/Logger.js';
+/**
+ * Detecta se está rodando em ambiente Azure/Linux
+ * @returns true se for Azure/Linux, false se for Windows local
+ */
+function isAzureEnvironment() {
+    // Consider Azure/CI when there are explicit CI pipeline signals.
+    // Do NOT classify 'darwin' (macOS) as Azure automatically.
+    if (process.env.TF_BUILD === 'True')
+        return true;
+    if (process.env.AGENT_NAME)
+        return true;
+    if (process.env.BUILD_BUILDID)
+        return true;
+    if (process.env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI)
+        return true;
+    // CI can be an auxiliary hint but not definitive alone
+    if (String(process.env.CI).toLowerCase() === 'true')
+        return true;
+    return false;
+}
+/**
+ * URLs do AutoCore Hub
+ */
+const HUB_URL_HOSTNAME = 'http://brtlvlty0559pl:3333';
+const HUB_URL_IP = 'http://10.129.170.238:3333';
+/**
+ * Obtém a URL correta do AutoCore Hub baseada no ambiente
+ * - Windows local: usa hostname interno (brtlvlty0559pl)
+ * - Azure/Linux: usa IP direto (10.129.170.238)
+ */
+function getAutoCorehubUrl() {
+    // Se variável de ambiente definida explicitamente, usar ela
+    if (process.env.AUTOCORE_HUB_URL) {
+        return process.env.AUTOCORE_HUB_URL;
+    }
+    // Detectar ambiente e usar URL apropriada
+    if (isAzureEnvironment()) {
+        return HUB_URL_IP;
+    }
+    else {
+        return HUB_URL_HOSTNAME;
+    }
+}
+/**
+ * Obtém URL de fallback (IP direto) caso a URL principal falhe
+ */
+function getFallbackHubUrl(currentUrl) {
+    // Se está usando hostname, fallback é o IP
+    if (currentUrl === HUB_URL_HOSTNAME) {
+        return HUB_URL_IP;
+    }
+    // Se está usando IP ou URL customizada, não há fallback
+    return null;
+}
+/**
+ * Helper para fazer fetch com timeout usando AbortController
+ */
+async function fetchWithTimeout(url, options = {}) {
+    const { timeout = 60000, ...fetchOptions } = options;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+        const response = await fetch(url, {
+            ...fetchOptions,
+            signal: controller.signal,
+        });
+        return response;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Verifica se o erro é retryável (502, 503, 504, conexão, etc.)
+ */
+function isRetryableError(error, status) {
+    // Erros HTTP retryáveis
+    if (status === 502 || status === 503 || status === 504) {
+        return true;
+    }
+    // Erros de conexão
+    const errorCode = error?.code || error?.cause?.code;
+    if (errorCode === 'ECONNRESET' ||
+        errorCode === 'ETIMEDOUT' ||
+        errorCode === 'ECONNREFUSED' ||
+        errorCode === 'ENOTFOUND' ||
+        errorCode === 'UND_ERR_CONNECT_TIMEOUT' ||
+        errorCode === 'UND_ERR_SOCKET') {
+        return true;
+    }
+    // AbortError (timeout)
+    if (error?.name === 'AbortError') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Cliente para comunicação com backend TestHub
+ * Usa fetch nativo do Node.js para evitar problemas com proxy corporativo
+ */
+export class TestHubClient {
+    static instance;
+    config;
+    systemsCache = null;
+    cacheFilePath;
+    cachedUserId = null;
+    cachedAuthToken = null;
+    cachedAuthTokenExpiry = 0;
+    hubApiUrl;
+    constructor(config) {
+        this.config = {
+            timeout: 60_000, // 60 segundos
+            retries: 5, // 5 retries
+            cacheEnabled: true,
+            cacheDuration: 10 * 60 * 1000, // 10 minutos
+            ...config,
+        };
+        // AutoCore Hub API URL - detecta ambiente automaticamente
+        this.hubApiUrl = getAutoCorehubUrl();
+        this.cacheFilePath = path.join(process.cwd(), 'test-results', '.testhub-systems-cache.json');
+    }
+    /**
+     * Obtém instância singleton do cliente
+     */
+    static getInstance(config) {
+        if (!TestHubClient.instance) {
+            const baseUrl = config?.baseUrl || process.env.TESTHUB_BASE_URL || getAutoCorehubUrl();
+            TestHubClient.instance = new TestHubClient({
+                baseUrl,
+                ...config,
+            });
+        }
+        return TestHubClient.instance;
+    }
+    /**
+     * Constrói headers padrão para requisições ao AutoCore Hub
+     * - Windows local: x-automation-user-matricula (USERNAME)
+     * - Linux/Azure: x-automation-user-email (email do pipeline)
+     * REGRA: Cada ambiente manda apenas o que tem disponível
+     */
+    async buildHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+            'User-Agent': 'AutoCore-Framework',
+            'Connection': 'keep-alive',
+        };
+        // x-automation-key should be configurable via env; fallback to legacy hardcoded
+        const automationKey = process.env.AUTOCORE_AUTOMATION_KEY || process.env.AUTOCORE_KEY || 'd8f3c4a9be7f29d1c6e04fa1a39c2e7bd91f57c8a3de45eb91c4f7a2d0e3b8fa';
+        if (automationKey)
+            headers['x-automation-key'] = automationKey;
+        // Prefer JWT token when available (env or login)
+        const envJwt = process.env.AUTOCORE_JWT_TOKEN;
+        let token = envJwt || null;
+        if (!token && this.cachedAuthToken && this.cachedAuthTokenExpiry > Date.now()) {
+            token = this.cachedAuthToken;
+        }
+        if (!token) {
+            // attempt to obtain token but don't throw here — headers should still include automation key
+            try {
+                token = await this.getAuthToken();
+            }
+            catch {
+                token = null;
+            }
+        }
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        // Identity headers: send email when available, otherwise matricula
+        const azureEmail = process.env.BUILD_REQUESTEDFOREMAIL || process.env.AUTOCORE_USER_EMAIL;
+        const buildReason = (process.env.BUILD_REASON || '').toString().toLowerCase();
+        const isScheduled = buildReason === 'schedule' || buildReason === 'scheduled';
+        if (azureEmail) {
+            if (isScheduled) {
+                // For scheduled runs, include trigger header and prefer technical identity if provided
+                headers['x-automation-trigger'] = 'schedule';
+                // prefer dedicated identity headers if present
+                if (process.env.AUTOCORE_USER_MATRICULA)
+                    headers['x-automation-user-matricula'] = process.env.AUTOCORE_USER_MATRICULA;
+                if (process.env.AUTOCORE_USER_EMAIL)
+                    headers['x-automation-user-email'] = process.env.AUTOCORE_USER_EMAIL;
+            }
+            else {
+                headers['x-automation-user-email'] = azureEmail;
+            }
+        }
+        else {
+            const matricula = process.env.AUTOCORE_USER_MATRICULA || process.env.USERNAME || process.env.USER || 'UNKNOWN';
+            headers['x-automation-user-matricula'] = matricula;
+        }
+        return headers;
+    }
+    /**
+     * Faz uma requisição GET com retry e fallback de URL
+     */
+    async fetchGet(endpoint, extraHeaders) {
+        const maxRetries = this.config.retries || 5;
+        let lastError = null;
+        // Lista de URLs para tentar (principal + fallback)
+        const urlsToTry = [this.hubApiUrl];
+        const fallbackUrl = getFallbackHubUrl(this.hubApiUrl);
+        if (fallbackUrl) {
+            urlsToTry.push(fallbackUrl);
+        }
+        for (const hubUrl of urlsToTry) {
+            for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                try {
+                    const url = `${hubUrl}${endpoint}`;
+                    const defaultHeaders = await this.buildHeaders();
+                    const response = await fetchWithTimeout(url, {
+                        method: 'GET',
+                        headers: {
+                            ...defaultHeaders,
+                            ...extraHeaders,
+                        },
+                        timeout: this.config.timeout,
+                    });
+                    if (!response.ok) {
+                        const errorText = await response.text().catch(() => '');
+                        const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+                        error.status = response.status;
+                        error.statusText = response.statusText;
+                        error.responseText = errorText;
+                        if (isRetryableError(error, response.status) && attempt < maxRetries) {
+                            const waitTime = Math.min(1000 * Math.pow(2, attempt), 30000);
+                            console.warn(`⚠️ Erro ${response.status} - Aguardando ${waitTime}ms antes de tentar novamente...`);
+                            await new Promise(resolve => setTimeout(resolve, waitTime));
+                            continue;
+                        }
+                        throw error;
+                    }
+                    // Atualizar URL do hub para usar a que funcionou
+                    if (hubUrl !== this.hubApiUrl) {
+                        console.log(`🔄 Atualizando URL do Hub para: ${hubUrl}`);
+                        this.hubApiUrl = hubUrl;
+                    }
+                    return await response.json();
+                }
+                catch (error) {
+                    lastError = error;
+                    // Enrich missing request metadata for debugging
+                    if (!error.requestUrl) {
+                        error.requestUrl = `${hubUrl}${endpoint}`;
+                        try {
+                            // build headers on-demand for error context
+                            // eslint-disable-next-line no-await-in-loop
+                            error.requestHeaders = await this.buildHeaders();
+                        }
+                        catch { }
+                    }
+                    if (isRetryableError(error) && attempt < maxRetries) {
+                        const waitTime = Math.min(1000 * Math.pow(2, attempt), 30000);
+                        Logger.warning(`⚠️ Erro ${error.code || error.name || 'desconhecido'} - Aguardando ${waitTime}ms antes de tentar novamente...`);
+                        await new Promise(resolve => setTimeout(resolve, waitTime));
+                        continue;
+                    }
+                    break;
+                }
+            }
+            Logger.warning(`⚠️ Falha ao conectar com ${hubUrl}, tentando próxima URL...`);
+        }
+        throw lastError;
+    }
+    /**
+     * Faz uma requisição POST com retry
+     */
+    async fetchPost(endpoint, body, extraHeaders) {
+        const maxRetries = this.config.retries || 5;
+        let lastError = null;
+        // Lista de URLs para tentar (principal + fallback)
+        const urlsToTry = [this.hubApiUrl];
+        const fallbackUrl = getFallbackHubUrl(this.hubApiUrl);
+        if (fallbackUrl) {
+            urlsToTry.push(fallbackUrl);
+        }
+        // Prepara headers para todas as tentativas
+        const requestHeaders = {
+            ...(await this.buildHeaders()),
+            ...extraHeaders,
+        };
+        const requestBody = JSON.stringify(body);
+        for (const hubUrl of urlsToTry) {
+            for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                try {
+                    const url = `${hubUrl}${endpoint}`;
+                    const response = await fetchWithTimeout(url, {
+                        method: 'POST',
+                        headers: requestHeaders,
+                        body: requestBody,
+                        timeout: this.config.timeout,
+                    });
+                    if (!response.ok) {
+                        const errorText = await response.text().catch(() => '');
+                        const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+                        error.status = response.status;
+                        error.statusText = response.statusText;
+                        error.responseText = errorText;
+                        error.requestUrl = url;
+                        error.requestHeaders = requestHeaders;
+                        error.requestBody = requestBody;
+                        if (isRetryableError(error, response.status) && attempt < maxRetries) {
+                            const waitTime = Math.min(1000 * Math.pow(2, attempt), 30000);
+                            Logger.warning(`⚠️ Erro ${response.status} - Aguardando ${waitTime}ms antes de tentar novamente...`);
+                            await new Promise(resolve => setTimeout(resolve, waitTime));
+                            continue;
+                        }
+                        throw error;
+                    }
+                    // Atualizar URL do hub para usar a que funcionou
+                    if (hubUrl !== this.hubApiUrl) {
+                        Logger.info(`🔄 Atualizando URL do Hub para: ${hubUrl}`);
+                        this.hubApiUrl = hubUrl;
+                    }
+                    return await response.json();
+                }
+                catch (error) {
+                    lastError = error;
+                    // 🔧 Adiciona detalhes da requisição ao erro para debug
+                    if (!error.requestUrl) {
+                        error.requestUrl = `${hubUrl}${endpoint}`;
+                        error.requestHeaders = requestHeaders;
+                        error.requestBody = requestBody;
+                    }
+                    if (isRetryableError(error) && attempt < maxRetries) {
+                        const waitTime = Math.min(1000 * Math.pow(2, attempt), 30000);
+                        Logger.warning(`⚠️ Erro ${error.code || error.name || 'desconhecido'} - Aguardando ${waitTime}ms antes de tentar novamente...`);
+                        await new Promise(resolve => setTimeout(resolve, waitTime));
+                        continue;
+                    }
+                    break;
+                }
+            }
+            Logger.warning(`⚠️ Falha ao conectar com ${hubUrl}, tentando próxima URL...`);
+        }
+        throw lastError;
+    }
+    /**
+     * 📡 Busca lista de sistemas do backend
+     * @returns Lista de sistemas cadastrados
+     */
+    async getSystems() {
+        // Verificar cache primeiro (sempre priorizar cache para evitar 502)
+        if (this.config.cacheEnabled && this.isCacheValid()) {
+            return this.systemsCache.systems;
+        }
+        // Tentar carregar do cache de arquivo antes de fazer request
+        if (this.loadSystemsFromFileCache()) {
+            Logger.info('📦 Usando cache de sistemas (pré-carregado)');
+            return this.systemsCache.systems;
+        }
+        try {
+            Logger.info(`📡 Buscando sistemas do AutoCore Hub...`);
+            // Garantir token JWT e usar rota oficial em português
+            const token = await this.getAuthToken().catch((e) => {
+                Logger.warning('⚠️ Não foi possível obter token JWT, prosseguindo com chave de API');
+                return null;
+            });
+            const extraHeaders = {};
+            if (token)
+                extraHeaders['Authorization'] = `Bearer ${token}`;
+            const data = await this.fetchGet('/api/sistemas', extraHeaders);
+            // Converter formato do AutoCore Hub para TestHub
+            const systems = this.convertHubSystemsToTestHub(data);
+            Logger.success(`✅ ${systems.length} sistema(s) carregado(s) do AutoCore Hub`);
+            // Salvar em cache
+            if (this.config.cacheEnabled) {
+                this.saveSystemsToCache(systems);
+            }
+            return systems;
+        }
+        catch (error) {
+            Logger.error(`❌ Erro ao buscar sistemas do AutoCore Hub: ${error?.message}`);
+            Logger.error('🔍 Detalhes do erro:');
+            Logger.error(`   - Código do erro: ${error?.code || error?.cause?.code || 'N/A'}`);
+            Logger.error(`   - Status HTTP: ${error?.status || 'N/A'}`);
+            // Tentar carregar do cache em caso de erro (fallback final)
+            if (this.loadSystemsFromFileCache()) {
+                Logger.warning('⚠️ Usando cache de sistemas (AutoCore Hub indisponível)');
+                Logger.warning(`📦 ${this.systemsCache.systems.length} sistema(s) carregado(s) do cache`);
+                return this.systemsCache.systems;
+            }
+            Logger.warning('⚠️ Nenhum sistema disponível. Continuando sem integração AutoCore Hub.');
+            return [];
+        }
+    }
+    /**
+     * 📤 Envia resultado de execução em batch para o backend
+     * @param batchPayload Dados completos da execução (batch)
+     * @returns IDs das execuções criadas
+     */
+    async sendBatchExecution(batchPayload) {
+        try {
+            Logger.info('📤 Iniciando envio do batch para AutoCore Hub...');
+            const startTime = Date.now();
+            // Garantir que `systemName` esteja presente no payload (backend exige)
+            if (!batchPayload || !batchPayload.systemName) {
+                const fallbackSystem = process.env.AUTOCORE_SYSTEM_NAME || 'Unknown';
+                try {
+                    Logger.warning(`[TestHubClient] batchPayload.systemName ausente — usando fallback: ${fallbackSystem}`);
+                }
+                catch { }
+                batchPayload = { ...(batchPayload || {}), systemName: fallbackSystem };
+            }
+            const response = await this.fetchPost('/api/execucoes/batch', batchPayload);
+            const duration = Date.now() - startTime;
+            Logger.info(`⏱️ Tempo de envio: ${duration}ms`);
+            if (response?.success) {
+                Logger.success('✅ Resposta do Hub recebida com sucesso!');
+                return response.executionIds || [];
+            }
+            Logger.warning(`⚠️ Resposta inesperada do AutoCore Hub`);
+            return [];
+        }
+        catch (error) {
+            Logger.error(`❌ Erro ao enviar batch para AutoCore Hub: ${error.message}`);
+            Logger.error('🔍 Detalhes do erro:');
+            Logger.error(`   - Código do erro: ${error.code || error?.cause?.code || 'N/A'}`);
+            Logger.error(`   - Status HTTP: ${error.status || 'N/A'}`);
+            if (error.responseText) {
+                Logger.error(`   - Resposta do servidor: ${error.responseText}`);
+            }
+            // Salvar localmente para retry posterior
+            this.saveFailedBatchExecution(batchPayload);
+            throw error;
+        }
+    }
+    /**
+     * 📦 Envia artifacts (relatórios compactados em Base64) para o backend
+     * @param artifactsPayload Dados dos artifacts
+     */
+    async sendArtifacts(artifactsPayload) {
+        try {
+            await this.fetchPost('/api/execucoes/artifacts', artifactsPayload);
+        }
+        catch (error) {
+            console.error('❌ Erro ao enviar artifacts para AutoCore Hub:', error.message);
+            console.error('🔍 Detalhes do erro:');
+            console.error(`   - Código do erro: ${error.code || error?.cause?.code || 'N/A'}`);
+            console.error(`   - Status HTTP: ${error.status || 'N/A'}`);
+            console.warn('⚠️ Continuando sem envio de artifacts...');
+        }
+    }
+    /**
+     * 🔍 Busca sistema por nome
+     * @param systemName Nome do sistema
+     * @returns Sistema encontrado ou null
+     */
+    async getSystemByName(systemName) {
+        const systems = await this.getSystems();
+        const normalizedSearchName = systemName.toLowerCase().trim();
+        const foundSystem = systems.find((s) => s.name.toLowerCase().trim() === normalizedSearchName) || null;
+        if (foundSystem) {
+            console.log(`✅ Sistema encontrado: ${foundSystem.name} (ID: ${foundSystem.id})`);
+        }
+        else {
+            console.warn(`❌ Sistema "${systemName}" não encontrado`);
+            console.warn(`💡 Sistemas disponíveis: ${systems.map((s) => s.name).join(', ')}`);
+        }
+        return foundSystem;
+    }
+    /**
+     * 🔍 Busca sistemas por tipo de ambiente
+     * @param type Tipo de ambiente (API, WEB, SSH, BANCO)
+     * @returns Lista de sistemas filtrados
+     */
+    async getSystemsByType(type) {
+        console.log(`🔍 Buscando sistemas por tipo de ambiente: "${type}"`);
+        const systems = await this.getSystems();
+        console.log(`📊 Total de sistemas disponíveis: ${systems.length}`);
+        const filteredSystems = systems.filter((system) => {
+            const hasType = system.environments.some((env) => env.type === type);
+            console.log(`📋 Sistema "${system.name}": ${hasType ? '✅ tem' : '❌ não tem'} ambiente ${type}`);
+            if (hasType) {
+                const envs = system.environments.filter((env) => env.type === type);
+                console.log(`   Ambientes ${type}:`, envs.map((env) => `${env.name} (${env.url})`).join(', '));
+            }
+            return hasType;
+        });
+        console.log(`✅ ${filteredSystems.length} sistema(s) encontrado(s) com ambiente ${type}`);
+        console.log(`📋 Sistemas filtrados:`, filteredSystems.map((s) => s.name).join(', '));
+        return filteredSystems;
+    }
+    /**
+     * 🔍 Busca ambiente específico de um sistema
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente (ex: 'preprod', 'esteira1')
+     * @returns Ambiente encontrado ou null
+     */
+    async getEnvironment(systemName, environmentName) {
+        console.log(`🔍 Buscando ambiente "${environmentName}" no sistema "${systemName}"`);
+        const system = await this.getSystemByName(systemName);
+        if (!system) {
+            console.error(`❌ Sistema "${systemName}" não encontrado`);
+            return null;
+        }
+        console.log(`📊 Total de ambientes no sistema: ${system.environments.length}`);
+        const normalizedEnvName = environmentName.toLowerCase().trim();
+        const foundEnvironment = system.environments.find((env) => env.name.toLowerCase().trim() === normalizedEnvName) || null;
+        if (foundEnvironment) {
+            console.log(`✅ Ambiente encontrado: ${foundEnvironment.name}`);
+        }
+        else {
+            console.warn(`❌ Ambiente "${environmentName}" não encontrado no sistema "${systemName}"`);
+            console.warn(`💡 Ambientes disponíveis: ${system.environments.map((env) => env.name).join(', ')}`);
+        }
+        return foundEnvironment;
+    }
+    /**
+     * 🔑 Busca todas as variáveis de ambiente de um sistema/ambiente específico
+     * Inclui automaticamente campos do ambiente como variáveis:
+     * - URL, USERNAME, PASSWORD, PORT
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente (ex: 'Prod', 'Homolog')
+     * @returns Array de variáveis ou array vazio
+     */
+    async getEnvironmentVariables(systemName, environmentName) {
+        console.log(`🔑 Buscando variáveis do ambiente "${environmentName}" no sistema "${systemName}"`);
+        const environment = await this.getEnvironment(systemName, environmentName);
+        if (!environment) {
+            console.warn(`⚠️ Ambiente não encontrado, retornando array vazio`);
+            return [];
+        }
+        // Preferir `frameworkVariables` quando presente (fonte prioritaria)
+        const frameworkVars = environment.frameworkVariables || {};
+        // Validar requiredFrameworkVariables
+        const required = environment.requiredFrameworkVariables || [];
+        const missingKeys = required.filter((k) => !(k in frameworkVars));
+        if (missingKeys.length > 0) {
+            throw new Error(`Missing framework variables for system=${systemName} env=${environmentName} required: ${missingKeys.join(', ')}`);
+        }
+        // Validar chaves críticas com valor não vazio
+        const critical = ['URL', 'PORT', 'USERNAME', 'PASSWORD'];
+        const emptyCritical = critical.filter((k) => !String(frameworkVars[k] ?? '').trim());
+        if (emptyCritical.length > 0) {
+            throw new Error(`Sem permissao ou configuracao incompleta para system=${environmentName} keys: ${emptyCritical.join(', ')}`);
+        }
+        // Converter para EnvironmentVariable[] preservando chaves do objeto
+        const variables = Object.keys(frameworkVars).map((k) => ({
+            id: `auto-${k.toLowerCase()}`,
+            key: k,
+            value: String(frameworkVars[k] ?? ''),
+        }));
+        // Incluir também campos básicos do ambiente como fallback/metadata (sem expor valores sensíveis extra)
+        variables.push({ id: 'auto-env-id', key: 'ENVIRONMENT_ID', value: environment.id || '' });
+        if (environment.name)
+            variables.push({ id: 'auto-env-name', key: 'ENVIRONMENT_NAME', value: environment.name });
+        if (environment.type)
+            variables.push({ id: 'auto-env-type', key: 'ENVIRONMENT_TYPE', value: environment.type });
+        console.log(`📋 ${variables.length} variável(is) preparada(s) (chaves somente).`);
+        return variables;
+    }
+    /**
+     * Obtém token JWT do AutoCore Hub e faz cache com expiry simples.
+     */
+    async getAuthToken() {
+        const now = Date.now();
+        if (this.cachedAuthToken && this.cachedAuthTokenExpiry > now)
+            return this.cachedAuthToken;
+        // 1) Prefer explicit env token
+        const envToken = process.env.AUTOCORE_JWT_TOKEN;
+        if (envToken) {
+            // No expiry info in env token, cache for short period
+            this.cachedAuthToken = envToken;
+            this.cachedAuthTokenExpiry = Date.now() + 30 * 60 * 1000; // 30 minutes
+            return envToken;
+        }
+        // 2) Attempt login with identifier/email + password if provided
+        const identifier = process.env.AUTOCORE_LOGIN_IDENTIFIER || process.env.AUTOCORE_LOGIN_EMAIL;
+        const password = process.env.AUTOCORE_LOGIN_PASSWORD;
+        if (identifier && password) {
+            try {
+                const payload = { password };
+                // prefer using 'identifier' key when AUTOCORE_LOGIN_IDENTIFIER set
+                if (process.env.AUTOCORE_LOGIN_IDENTIFIER)
+                    payload.identifier = process.env.AUTOCORE_LOGIN_IDENTIFIER;
+                else
+                    payload.email = process.env.AUTOCORE_LOGIN_EMAIL;
+                const resp = await this.fetchPost('/auth/login', payload);
+                const token = resp?.token || resp?.accessToken || resp?.jwt;
+                const expiresIn = resp?.expiresIn || resp?.expires_seconds || 60 * 60;
+                if (token) {
+                    this.cachedAuthToken = token;
+                    this.cachedAuthTokenExpiry = Date.now() + (Number(expiresIn) * 1000) - 60_000;
+                    return token;
+                }
+            }
+            catch (e) {
+                console.warn('⚠️ Falha ao autenticar via /auth/login com AUTOCORE_LOGIN_*, prosseguindo sem JWT');
+            }
+        }
+        // 3) No token available
+        return null;
+    }
+    /**
+     * Retorna um mapa de variáveis final para execução escolhendo credencial com sufixo quando informado.
+     * - Sufixo nulo => usa chaves padrão (URL, USERNAME...)
+     * - Sufixo 'PARCEIRO' => prefere URL_PARCEIRO etc, mas faz fallback para padrão quando ausente
+     */
+    async getFrameworkVariablesForExecution(systemName, environmentName, credentialSuffix) {
+        const environment = await this.getEnvironment(systemName, environmentName);
+        if (!environment)
+            throw new Error(`Ambiente ${environmentName} / ${systemName} não encontrado`);
+        const frameworkVars = environment.frameworkVariables || {};
+        // Validate required keys existence (backend declares which keys must exist)
+        const required = environment.requiredFrameworkVariables || [];
+        const missingKeys = required.filter((k) => !(k in frameworkVars));
+        if (missingKeys.length > 0)
+            throw new Error(`Missing framework variables for system=${systemName} env=${environmentName}: ${missingKeys.join(', ')}`);
+        // Use credential selection flow to pick suffix + concrete credentials.
+        // This keeps selection logic consistent with getCredentialSetForEnvironment.
+        const { suffix, credentialSet } = await this.getCredentialSetForEnvironment(systemName, environmentName, credentialSuffix);
+        // Start with all framework variables (preserve custom keys like ADB_*)
+        const result = {};
+        for (const key of Object.keys(frameworkVars)) {
+            result[key] = String(frameworkVars[key] ?? '');
+        }
+        // Overwrite base keys with the selected credential set (so callers can read URL/PORT/USERNAME/PASSWORD)
+        result['URL'] = String(credentialSet.url ?? '');
+        result['PORT'] = String(credentialSet.port ?? '');
+        result['SERVICE'] = String(credentialSet.service ?? '');
+        result['USERNAME'] = String(credentialSet.username ?? '');
+        result['PASSWORD'] = String(credentialSet.password ?? '');
+        // Also ensure suffixed keys exist (map chosen values to suffixed keys when applicable)
+        if (suffix) {
+            const su = String(suffix).toUpperCase();
+            result[`URL_${su}`] = result[`URL_${su}`] ?? result['URL'];
+            result[`PORT_${su}`] = result[`PORT_${su}`] ?? result['PORT'];
+            result[`SERVICE_${su}`] = result[`SERVICE_${su}`] ?? result['SERVICE'];
+            result[`USERNAME_${su}`] = result[`USERNAME_${su}`] ?? result['USERNAME'];
+            result[`PASSWORD_${su}`] = result[`PASSWORD_${su}`] ?? result['PASSWORD'];
+        }
+        // Final critical check
+        const critical = ['URL', 'PORT', 'USERNAME', 'PASSWORD'];
+        const emptyCritical = critical.filter((k) => !String(result[k] ?? '').trim());
+        if (emptyCritical.length > 0) {
+            throw new Error(`Sem permissao ou configuracao incompleta para: ${emptyCritical.join(', ')}`);
+        }
+        return result;
+    }
+    /**
+     * Retorna os sufixos de credenciais disponíveis para um ambiente (inclui null/default)
+     */
+    async getAvailableCredentialSuffixes(systemName, environmentName) {
+        const env = await this.getEnvironment(systemName, environmentName);
+        if (!env)
+            return [];
+        const creds = env.credentials || [];
+        const suffixes = [];
+        // Sempre incluir default (null) se existir
+        if (creds.some((c) => c.isDefault))
+            suffixes.push(null);
+        // Adicionar todos os sufixos ativos não-nulos
+        for (const c of creds) {
+            if (c.suffix && !suffixes.includes(c.suffix))
+                suffixes.push(String(c.suffix).toUpperCase());
+        }
+        // Se não houver credencial marcada como default, garantir que pelo menos null exista (fallback)
+        if (suffixes.length === 0)
+            suffixes.push(null);
+        return suffixes;
+    }
+    /**
+     * Constrói um conjunto de credenciais (URL/PORT/SERVICE/USERNAME/PASSWORD) a partir do mapa de framework vars
+     */
+    getCredentialSetFromVars(vars, suffix) {
+        const normalizedSuffix = String(suffix ?? '').trim().toUpperCase();
+        const prefix = normalizedSuffix ? `_${normalizedSuffix}` : '';
+        return {
+            url: String(vars[`URL${prefix}`] ?? ''),
+            port: String(vars[`PORT${prefix}`] ?? ''),
+            service: String(vars[`SERVICE${prefix}`] ?? ''),
+            username: String(vars[`USERNAME${prefix}`] ?? ''),
+            password: String(vars[`PASSWORD${prefix}`] ?? ''),
+        };
+    }
+    /**
+     * Retorna o conjunto de credenciais efetivo para execução, escolhendo por sufixo ou fallback
+     */
+    async getCredentialSetForEnvironment(systemName, environmentName, requestedSuffix) {
+        const env = await this.getEnvironment(systemName, environmentName);
+        if (!env)
+            throw new Error(`Ambiente ${environmentName} do sistema ${systemName} não encontrado`);
+        const frameworkVars = env.frameworkVariables || {};
+        const required = env.requiredFrameworkVariables || [];
+        // Validar requiredFrameworkVariables
+        const missing = required.filter((k) => !(k in frameworkVars));
+        if (missing.length > 0)
+            throw new Error(`Missing required framework variables for system=${systemName} env=${environmentName}: ${missing.join(', ')}`);
+        // Preferir credenciais ativas com sufixo solicitado
+        const creds = env.credentials || [];
+        let suffixToUse = null;
+        if (requestedSuffix) {
+            const found = creds.find((c) => String(c.suffix ?? '').toUpperCase() === String(requestedSuffix).toUpperCase() && c.isActive);
+            if (found)
+                suffixToUse = String(found.suffix ?? '').toUpperCase();
+        }
+        // Se não pediu ou não encontrou, usar default credential quando existir
+        if (suffixToUse === null) {
+            const def = creds.find((c) => c.isDefault && c.isActive);
+            if (def)
+                suffixToUse = def.suffix ?? null;
+        }
+        // Se ainda não decidiu, tentar pegar o primeiro ativo com sufixo
+        if (suffixToUse === null) {
+            const firstSuff = creds.find((c) => c.suffix && c.isActive);
+            if (firstSuff)
+                suffixToUse = String(firstSuff.suffix).toUpperCase();
+        }
+        // Build vars and credential set
+        const mergedVars = {};
+        for (const k of Object.keys(frameworkVars))
+            mergedVars[k] = String(frameworkVars[k] ?? '');
+        const credentialSet = this.getCredentialSetFromVars(mergedVars, suffixToUse);
+        // Final validation: critical keys
+        const critical = ['url', 'port', 'username', 'password'];
+        const empty = critical.filter((k) => !String(credentialSet[k] ?? '').trim());
+        if (empty.length > 0) {
+            throw new Error(`Credenciais incompletas para system=${systemName} env=${environmentName} sufixo=${suffixToUse ?? 'DEFAULT'}: ${empty.join(', ')}`);
+        }
+        return { suffix: suffixToUse, credentialSet };
+    }
+    /**
+     * Resolve um valor possivelmente placeholder usando as frameworkVariables ou credentials do ambiente.
+     * - Se `input` for uma chave (ex: "USERNAME", "ADB_VENDA") tenta buscar em frameworkVariables
+     * - Se for uma das chaves base (USERNAME/PASSWORD/URL/PORT/SERVICE) e não existir como variável, usa o credentialSet
+     * - Caso contrário retorna `input` inalterado
+     */
+    async resolveFrameworkValue(systemName, environmentName, input, credentialSuffix) {
+        if (!input && input !== '')
+            return null;
+        const raw = String(input ?? '');
+        // If empty string, return as-is
+        if (raw.trim() === '')
+            return raw;
+        const env = await this.getEnvironment(systemName, environmentName);
+        if (!env)
+            return raw;
+        const frameworkVars = env.frameworkVariables || {};
+        const keyCandidate = raw.toUpperCase().trim();
+        // First try exact key in frameworkVariables (case-sensitive keys exist as uppercase in hub)
+        if (keyCandidate in frameworkVars && String(frameworkVars[keyCandidate] ?? '').trim() !== '') {
+            return String(frameworkVars[keyCandidate]);
+        }
+        // If a suffix was requested, try suffixed key
+        if (credentialSuffix) {
+            const su = String(credentialSuffix).toUpperCase();
+            const suffKey = `${keyCandidate}_${su}`;
+            if (suffKey in frameworkVars && String(frameworkVars[suffKey] ?? '').trim() !== '') {
+                return String(frameworkVars[suffKey]);
+            }
+        }
+        // If the input is one of the base credential keys, fallback to credentialSet
+        const baseMap = {
+            USERNAME: 'username',
+            PASSWORD: 'password',
+            URL: 'url',
+            PORT: 'port',
+            SERVICE: 'service',
+        };
+        if (Object.prototype.hasOwnProperty.call(baseMap, keyCandidate)) {
+            try {
+                const { credentialSet } = await this.getCredentialSetForEnvironment(systemName, environmentName, credentialSuffix);
+                const mapped = credentialSet[baseMap[keyCandidate]];
+                if (mapped && String(mapped).trim() !== '')
+                    return String(mapped);
+            }
+            catch (e) {
+                // ignore and fallback to raw
+            }
+        }
+        // Last attempt: look for case-insensitive match in frameworkVars
+        const foundKey = Object.keys(frameworkVars).find((k) => k.toLowerCase() === keyCandidate.toLowerCase());
+        if (foundKey && String(frameworkVars[foundKey] ?? '').trim() !== '')
+            return String(frameworkVars[foundKey]);
+        return raw;
+    }
+    /**
+     * 🔍 Busca uma variável específica por chave
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente
+     * @param variableKey Chave da variável (ex: 'BASE_URL', 'API_TOKEN')
+     * @returns Valor da variável ou null se não encontrada
+     */
+    async getEnvironmentVariable(systemName, environmentName, variableKey) {
+        console.log(`🔍 Buscando variável "${variableKey}" em ${systemName}/${environmentName}`);
+        const variables = await this.getEnvironmentVariables(systemName, environmentName);
+        const variable = variables.find((v) => v.key.toLowerCase() === variableKey.toLowerCase());
+        if (variable) {
+            console.log(`✅ Variável encontrada: ${variableKey}`);
+            return variable.value;
+        }
+        console.warn(`⚠️ Variável "${variableKey}" não encontrada`);
+        return null;
+    }
+    /**
+     * 🌍 Carrega todas as variáveis de um ambiente como variáveis de ambiente do processo
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente
+     * @param prefix Prefixo opcional para as variáveis (ex: 'AUTOCORE_')
+     * @returns Número de variáveis carregadas
+     */
+    async loadEnvironmentVariables(systemName, environmentName, prefix = '') {
+        console.log(`🌍 Carregando variáveis de ${systemName}/${environmentName} para process.env`);
+        const variables = await this.getEnvironmentVariables(systemName, environmentName);
+        let loaded = 0;
+        for (const variable of variables) {
+            const envKey = prefix ? `${prefix}${variable.key}` : variable.key;
+            process.env[envKey] = variable.value;
+            loaded++;
+            console.log(`   ✅ ${envKey} carregada`);
+        }
+        console.log(`📦 ${loaded} variável(is) carregada(s) em process.env`);
+        return loaded;
+    }
+    /**
+     * 📝 Retorna todas as variáveis como um objeto chave-valor
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente
+     * @returns Objeto com chave-valor das variáveis
+     */
+    async getVariablesAsObject(systemName, environmentName) {
+        const variables = await this.getEnvironmentVariables(systemName, environmentName);
+        const result = {};
+        for (const variable of variables) {
+            result[variable.key] = variable.value;
+        }
+        return result;
+    }
+    /**
+     * Verifica se o cache é válido
+     */
+    isCacheValid() {
+        if (!this.systemsCache) {
+            return this.loadSystemsFromFileCache();
+        }
+        const now = Date.now();
+        const cacheAge = now - this.systemsCache.timestamp;
+        return cacheAge < (this.config.cacheDuration || 300_000);
+    }
+    /**
+     * Salva sistemas no cache em memória e arquivo
+     */
+    saveSystemsToCache(systems) {
+        this.systemsCache = {
+            systems,
+            timestamp: Date.now(),
+        };
+        // Salvar em arquivo para persistência
+        try {
+            const cacheDir = path.dirname(this.cacheFilePath);
+            if (!fs.existsSync(cacheDir)) {
+                fs.mkdirSync(cacheDir, { recursive: true });
+            }
+            const cacheData = JSON.stringify(this.systemsCache, null, 2);
+            fs.writeFileSync(this.cacheFilePath, cacheData);
+        }
+        catch (error) {
+            console.warn('⚠️ Erro ao salvar cache de sistemas:', error);
+        }
+    }
+    /**
+     * Carrega sistemas do cache em arquivo
+     */
+    loadSystemsFromFileCache() {
+        try {
+            if (fs.existsSync(this.cacheFilePath)) {
+                const cacheData = fs.readFileSync(this.cacheFilePath, 'utf-8');
+                this.systemsCache = JSON.parse(cacheData);
+                return this.isCacheValid();
+            }
+            return false;
+        }
+        catch (error) {
+            console.warn('⚠️ Erro ao carregar cache de sistemas:', error);
+            return false;
+        }
+    }
+    /**
+     * Salva execução que falhou para retry posterior
+     */
+    saveFailedBatchExecution(batchPayload) {
+        console.log(`💾 Salvando batch falhado para retry posterior...`);
+        try {
+            const failedDir = path.join(process.cwd(), '.rbqa', '.testhub-failed-batches');
+            if (!fs.existsSync(failedDir)) {
+                fs.mkdirSync(failedDir, { recursive: true });
+            }
+            const timestamp = Date.now();
+            const fileName = `batch-${timestamp}.json`;
+            const filePath = path.join(failedDir, fileName);
+            fs.writeFileSync(filePath, JSON.stringify(batchPayload, null, 2));
+            console.log(`✅ Batch salvo para retry: ${fileName}`);
+        }
+        catch (error) {
+            console.error('❌ Erro ao salvar batch falhado:', error);
+        }
+    }
+    /**
+     * Limpa cache de sistemas
+     */
+    clearCache() {
+        console.log(`🧹 Limpando cache de sistemas...`);
+        this.systemsCache = null;
+        console.log(`✅ Cache em memória limpo`);
+        try {
+            if (fs.existsSync(this.cacheFilePath)) {
+                fs.unlinkSync(this.cacheFilePath);
+                console.log(`✅ Arquivo de cache removido`);
+            }
+        }
+        catch (error) {
+            console.warn('⚠️ Erro ao limpar cache:', error);
+        }
+    }
+    /**
+     * Testa conectividade com o backend
+     */
+    async testConnection() {
+        console.log(`🔌 Testando conectividade com AutoCore Hub backend...`);
+        console.log(`🔗 URL de teste: ${this.hubApiUrl}/systems`);
+        try {
+            const startTime = Date.now();
+            await this.fetchGet('/systems');
+            const responseTime = Date.now() - startTime;
+            console.log(`✅ Conectividade OK - tempo de resposta: ${responseTime}ms`);
+            return true;
+        }
+        catch (error) {
+            console.error(`❌ Falha na conectividade com AutoCore Hub`);
+            console.error(`🔍 Detalhes da falha:`);
+            console.error(`   - Erro: ${error.message}`);
+            console.error(`   - Código: ${error.code || error?.cause?.code || 'N/A'}`);
+            console.error(`   - Status: ${error.status || 'N/A'}`);
+            return false;
+        }
+    }
+    /**
+     * Converte sistemas do AutoCore Hub para formato TestHub
+     */
+    convertHubSystemsToTestHub(hubSystems) {
+        const normalizeSystemType = (raw) => {
+            if (!raw && raw !== 0)
+                return 'Mixed';
+            const s = String(raw).toUpperCase();
+            // Map common backend tokens to friendly values used in framework
+            switch (s) {
+                case 'WEB':
+                    return 'Frontend';
+                case 'API':
+                    return 'API';
+                case 'SSH':
+                    return 'SSH';
+                case 'BANCO':
+                case 'DATABASE':
+                    return 'Banco';
+                case 'MOBILE':
+                    return 'Mobile';
+                case 'PROD':
+                case 'HML':
+                case 'DEV':
+                case 'STAGING':
+                case 'PRODUCTION':
+                    return s.toLowerCase();
+                default:
+                    return raw;
+            }
+        };
+        return hubSystems.map((hubSystem) => {
+            const systemType = normalizeSystemType(hubSystem.type || hubSystem.category || '');
+            return {
+                id: hubSystem.id,
+                name: hubSystem.name,
+                description: hubSystem.description || '',
+                url: hubSystem.url || '',
+                // Keep the backend-provided type (normalized) instead of forcing 'API'
+                type: systemType,
+                status: hubSystem.status,
+                isActive: hubSystem.isActive,
+                // isPrivate removed as per the patch
+                sidService: hubSystem.sidService,
+                environments: hubSystem.environments?.map((env) => {
+                    const envType = normalizeSystemType(env.type || env.environmentCategory || env.name || '');
+                    return {
+                        id: env.id,
+                        name: env.name,
+                        // preserve environment type from backend (ex: PROD, DEV) but normalize common tokens
+                        type: envType,
+                        url: env.url,
+                        port: env.port,
+                        username: env.username,
+                        password: env.password,
+                        serviceName: env.serviceName,
+                        privateKeyPath: env.privateKeyPath,
+                        environmentCategory: env.type || env.environmentCategory || env.name,
+                        variables: env.variables?.map((v) => ({
+                            id: v.id,
+                            key: v.key,
+                            value: v.value,
+                        })) || [],
+                        // Mapear novos campos retornados pelo backend (frameworkVariables / credentials)
+                        frameworkVariables: env.frameworkVariables || {},
+                        requiredFrameworkVariables: env.requiredFrameworkVariables || [],
+                        credentials: env.credentials?.map((c) => ({
+                            id: c.id,
+                            label: c.label,
+                            suffix: c.suffix ?? null,
+                            description: c.description ?? null,
+                            url: c.url ?? null,
+                            port: c.port ?? null,
+                            service: c.service ?? null,
+                            username: c.username ?? null,
+                            password: c.password ?? null,
+                            isDefault: c.isDefault ?? false,
+                            isActive: c.isActive ?? true,
+                            displayOrder: c.displayOrder ?? 0,
+                        })) || [],
+                        isPrivate: Boolean(env.isPrivate),
+                        privateMembers: env.privateMembers || [],
+                    };
+                }) || [],
+            };
+        });
+    }
+    /**
+     * Obtém User ID do AutoCore Hub (com autenticação automática)
+     */
+    async getUserId() {
+        if (this.cachedUserId) {
+            console.log('📦 Usando User ID em cache');
+            return this.cachedUserId;
+        }
+        console.log('🔐 Autenticando usuário no AutoCore Hub...');
+        const identifier = await this.getUserIdentifier();
+        try {
+            let user;
+            if (identifier.type === 'email') {
+                console.log(`📧 Buscando usuário por email: ${identifier.value}`);
+                user = await this.fetchGet(`/auth/user-by-email/${encodeURIComponent(identifier.value)}`);
+            }
+            else {
+                console.log(`🎫 Buscando usuário por matrícula: ${identifier.value}`);
+                user = await this.fetchGet(`/auth/user-by-matricula/${identifier.value}`);
+            }
+            this.cachedUserId = user.id;
+            console.log(`✅ Autenticado como: ${user.name} (${user.matricula})`);
+            console.log(`📧 Email: ${user.email}`);
+            console.log(`🏢 Diretoria: ${user.diretoria || 'N/A'}`);
+            console.log(`👥 Equipe: ${user.equipe || 'N/A'}`);
+            console.log(`🆔 User ID: ${user.id}`);
+            return user.id;
+        }
+        catch (error) {
+            if (error.status === 404) {
+                const notFoundMsg = identifier.type === 'email'
+                    ? `Usuário com email "${identifier.value}" não encontrado no AutoCore Hub`
+                    : `Usuário com matrícula "${identifier.value}" não encontrado no AutoCore Hub`;
+                console.error(`❌ ${notFoundMsg}`);
+                console.error('💡 Dica: Verifique se o usuário está cadastrado no AutoCore Hub');
+                throw new Error(notFoundMsg);
+            }
+            console.error('❌ Erro ao autenticar usuário:', error.message);
+            throw error;
+        }
+    }
+    /**
+     * Detecta ambiente de execução e obtém identificador do usuário
+     */
+    async getUserIdentifier() {
+        console.log('🔍 Detectando ambiente de execução...');
+        // Verificar se estamos em ambiente CI/Azure
+        if (isAzureEnvironment()) {
+            console.log('🔵 Azure Pipeline detectado');
+            // Tentar obter email do ambiente
+            let userEmail = process.env.BUILD_REQUESTEDFOREMAIL || process.env.AUTOCORE_USER_EMAIL;
+            if (!userEmail) {
+                console.log('📡 BUILD_REQUESTEDFOREMAIL não disponível, tentando Azure DevOps API...');
+                const apiEmail = await this.getAzureUserEmailFromAPI();
+                if (apiEmail) {
+                    userEmail = apiEmail;
+                }
+            }
+            if (userEmail) {
+                console.log(`👤 Azure User Email: ${userEmail}`);
+                // Verificar se o email contém uma matrícula (padrão A + 7 dígitos)
+                const matriculaMatch = userEmail.match(/A\d{7}/);
+                if (matriculaMatch) {
+                    console.log(`🎯 Matrícula extraída do email: ${matriculaMatch[0]}`);
+                    return { type: 'matricula', value: matriculaMatch[0] };
+                }
+                return { type: 'email', value: userEmail };
+            }
+            throw new Error('Não foi possível obter informações do usuário no Azure Pipeline. ' +
+                'Verifique se BUILD_REQUESTEDFOREMAIL está disponível ou configure AZURE_DEVOPS_PAT.');
+        }
+        else {
+            console.log('💻 Execução local detectada');
+            const matricula = process.env.AUTOCORE_USER_MATRICULA ||
+                process.env.USERNAME ||
+                process.env.USER;
+            if (!matricula) {
+                throw new Error('Matrícula não configurada para execução local. ' +
+                    'Configure AUTOCORE_USER_MATRICULA no .env ou defina USERNAME/USER.');
+            }
+            console.log(`👤 Matrícula local: ${matricula}`);
+            return { type: 'matricula', value: matricula };
+        }
+    }
+    /**
+     * Obtém email do usuário via Azure DevOps REST API
+     */
+    async getAzureUserEmailFromAPI() {
+        try {
+            const azureDevOpsPAT = process.env.AZURE_DEVOPS_PAT;
+            if (!azureDevOpsPAT) {
+                console.warn('⚠️ AZURE_DEVOPS_PAT não configurado, não é possível usar Azure DevOps API');
+                return null;
+            }
+            const organization = process.env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI?.split('/').pop() || '';
+            const project = process.env.SYSTEM_TEAMPROJECT || '';
+            const buildId = process.env.BUILD_BUILDID || '';
+            if (!organization || !project || !buildId) {
+                console.warn('⚠️ Variáveis do Azure Pipeline não disponíveis para API call');
+                return null;
+            }
+            const url = `https://dev.azure.com/${organization}/${project}/_apis/build/builds/${buildId}?api-version=7.2`;
+            console.log(`📡 Chamando Azure DevOps API: ${url}`);
+            const auth = Buffer.from(`:${azureDevOpsPAT}`).toString('base64');
+            const response = await fetchWithTimeout(url, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Basic ${auth}`,
+                    'Content-Type': 'application/json',
+                },
+                timeout: 10000,
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const buildInfo = await response.json();
+            const userEmail = buildInfo.requestedFor.uniqueName;
+            console.log(`✅ Azure DevOps API - Usuário: ${buildInfo.requestedFor.displayName}`);
+            console.log(`📧 Email obtido: ${userEmail}`);
+            console.log(`🏗️ Build: ${buildInfo.buildNumber}`);
+            return userEmail;
+        }
+        catch (error) {
+            console.error('❌ Erro ao chamar Azure DevOps API:', error.message);
+            console.error('💡 Dica: Verifique se AZURE_DEVOPS_PAT está configurado e tem permissões de Build (Read)');
+            return null;
+        }
+    }
+    /**
+     * Envia execução de cenário para o AutoCore Hub
+     */
+    async sendScenarioExecution(payload) {
+        console.log(`📤 Enviando execução de cenário: ${payload.cenarioNome}`);
+        console.log(`🎯 Sistema: ${payload.sistemaNome || 'N/A'}`);
+        console.log(`🌍 Ambiente: ${payload.ambiente}`);
+        console.log(`📊 Status: ${payload.status || 'executando'}`);
+        const userId = await this.getUserId();
+        try {
+            const response = await this.fetchPost('/execucoes-cenarios', payload, {
+                'X-User-Id': userId,
+            });
+            console.log(`✅ Execução criada no AutoCore Hub - ID: ${response.id}`);
+            return response.id;
+        }
+        catch (error) {
+            console.error('❌ Erro ao enviar execução para o AutoCore Hub:', error.message);
+            if (error.status === 400) {
+                console.error('🔍 Erro de validação - verifique o payload:');
+                console.error('📄 Payload enviado:', JSON.stringify(payload, null, 2));
+                if (error.responseText) {
+                    console.error('📋 Resposta do servidor:', error.responseText);
+                }
+            }
+            if (error.status === 401) {
+                console.error('🔐 Erro de autenticação - verifique se o User ID é válido');
+                console.error('🆔 User ID usado:', userId);
+            }
+            // Salvar execução localmente para retry
+            this.saveFailedScenarioExecution(payload);
+            throw error;
+        }
+    }
+    /**
+     * Salva execução de cenário falhada para retry posterior
+     */
+    saveFailedScenarioExecution(payload) {
+        try {
+            const failedDir = path.join(process.cwd(), 'test-results', '.hub-failed-scenarios');
+            if (!fs.existsSync(failedDir)) {
+                fs.mkdirSync(failedDir, { recursive: true });
+            }
+            const timestamp = Date.now();
+            const fileName = `scenario-${timestamp}.json`;
+            const filePath = path.join(failedDir, fileName);
+            fs.writeFileSync(filePath, JSON.stringify(payload, null, 2));
+            console.log(`💾 Execução de cenário salva para retry: ${fileName}`);
+        }
+        catch (error) {
+            console.error('❌ Erro ao salvar execução de cenário falhada:', error);
+        }
+    }
+}
+export default TestHubClient;