@silasfmartins/testhub 1.0.0

package/dist/src/api/ApiActions.js

@@ -0,0 +1,1905 @@
+import { createRequire } from 'node:module';
+import { request as playwrightRequest, } from '@playwright/test';
+import { IntegrationError, ValidationError, } from '../functions/errors/index.js';
+import { TestContext } from '../testContext/TestContext.js';
+import { UnifiedReportManager } from '../testContext/UnifiedReportManager.js';
+import { Logger } from '../utils/Logger.js';
+import { createCertificate } from './Certificate.js';
+import { JsonResponse } from './JsonResponse.js';
+// 🤖 IMPORTAÇÃO CRÍTICA: Força inicialização do StatementTracker
+import '../hubdocs/StatementTracker.js';
+import { ExecutionTracker } from '../hubdocs/ExecutionTracker.js';
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+import DynamicConfigManager from '../testhub/DynamicConfigManager.js';
+export { createCertificate };
+/**
+ * ✅ APIACTIONS DEFINITIVA: Interface Nova Avançada
+ *
+ * Interface Unificada:
+ * - get(request, descrição, ignoreSSL) -> ApiResponse
+ * - post(request, descrição, ignoreSSL) -> ApiResponse
+ *
+ * Melhorias Incluídas:
+ * - Tratamento de erros especializado
+ * - Logs estruturados e mascaramento de dados sensíveis
+ * - Métricas de performance automáticas
+ * - Compatibilidade com TestContext automática
+ * - Bypass automático do sistema de proteção
+ */
+export class ApiActions {
+    static successCount = 0;
+    static failureCount = 0;
+    static inicioExecucao;
+    static fimExecucao;
+    static logsPerTest = {};
+    static duracoes = [];
+    static foiUsado = false;
+    static requestCount = 0;
+    static contextCache = new Map();
+    static dadosGerais = {
+        inicio: null,
+        fim: null,
+        totalRequisicoes: 0,
+        totalSuccesso: 0,
+        totalFalhas: 0,
+    };
+    static marcarUsoAutomatico() {
+        if (!ApiActions.foiUsado) {
+            ApiActions.foiUsado = true;
+            ApiActions.registrarInicioExecucao();
+        }
+    }
+    /**
+     * ✅ Limpa o cache de contextos, descartando recursos corretamente
+     * Deve ser chamado quando um novo CT inicia ou quando o sistema muda
+     */
+    static async clearContextCache() {
+        const disposePromises = [];
+        for (const ctx of ApiActions.contextCache.values()) {
+            disposePromises.push(ctx.dispose().catch(() => { }));
+        }
+        await Promise.all(disposePromises);
+        ApiActions.contextCache.clear();
+    }
+    /**
+     * ✅ Garante que TestContext.apiContext existe
+     */
+    static async ensureApiContext() {
+        try {
+            // Tentar usar TestContext.apiContext se disponível
+            return await TestContext.getOrCreateApiContext();
+        }
+        catch {
+            // Fallback: criar contexto direto
+            return await playwrightRequest.newContext({
+                ignoreHTTPSErrors: true,
+            });
+        }
+    }
+    static createApiResponse(statusCode, responseHeaders, responseBody, duration) {
+        // ✅ VALIDAÇÃO CRÍTICA: Garantir que os parâmetros são válidos
+        const safeStatusCode = typeof statusCode === 'number' ? statusCode : 500;
+        const safeHeaders = responseHeaders || {};
+        const safeBody = typeof responseBody === 'string'
+            ? responseBody
+            : JSON.stringify({ error: 'Invalid response body' });
+        const safeDuration = typeof duration === 'number' ? duration : 0;
+        const jsonResponse = new JsonResponse(ApiActions.tryParseJson(safeBody));
+        jsonResponse.setStatus(safeStatusCode);
+        const apiResponse = {
+            status: () => safeStatusCode,
+            getStatus: () => safeStatusCode,
+            headers: () => safeHeaders,
+            text: () => safeBody,
+            getString: (key) => jsonResponse.getString(key),
+            get: (key) => jsonResponse.get(key),
+            getArray: (key) => jsonResponse.getArray(key),
+            getObject: (key) => jsonResponse.getObject(key),
+            getFromArray: (index) => jsonResponse.getFromArray(index),
+            getStringFromArray: (index, field) => jsonResponse.getStringFromArray(index, field),
+            getPath: (...path) => jsonResponse.getPath(...path),
+            raw: () => jsonResponse.raw(),
+            duration: safeDuration,
+        };
+        // ✅ VALIDAÇÃO FINAL: Verificar se o objeto criado é válido
+        if (!apiResponse || typeof apiResponse.getStatus !== 'function') {
+            Logger.error('❌ ApiResponse criado é inválido!');
+            throw new Error('Falha crítica ao criar ApiResponse válido');
+        }
+        return apiResponse;
+    }
+    static foiUtilizado() {
+        return ApiActions.foiUsado || ApiActions.requestCount > 0;
+    }
+    static registrarInicioExecucao() {
+        if (!ApiActions.inicioExecucao) {
+            ApiActions.inicioExecucao = new Date();
+            ApiActions.dadosGerais.inicio = ApiActions.inicioExecucao;
+            console.log(`⏱️  Início da execução API registrado: ${ApiActions.inicioExecucao.toLocaleTimeString()}`);
+        }
+    }
+    static registrarFimExecucao() {
+        ApiActions.fimExecucao = new Date();
+        ApiActions.dadosGerais.totalRequisicoes = ApiActions.requestCount;
+        ApiActions.dadosGerais.totalSuccesso = ApiActions.successCount;
+        ApiActions.dadosGerais.totalFalhas = ApiActions.failureCount;
+        ApiActions.dadosGerais.fim = ApiActions.fimExecucao;
+        if (!ApiActions.dadosGerais.inicio) {
+            ApiActions.dadosGerais.inicio = ApiActions.inicioExecucao;
+        }
+        if (ApiActions.inicioExecucao) {
+            const duracao = (ApiActions.fimExecucao.getTime() -
+                ApiActions.inicioExecucao.getTime()) /
+                1000;
+            Logger.info(`⏱️  Execução de APIs concluída em ${duracao.toFixed(2)}s`);
+        }
+    }
+    static logEvent(message) {
+        if (message.includes('[API]') || message.includes('Log registrado')) {
+            return;
+        }
+        ApiActions.marcarUsoAutomatico();
+        const testInfo = TestContext.getSafeTestInfo();
+        const testId = testInfo?.title || 'global';
+        if (!ApiActions.logsPerTest[testId])
+            ApiActions.logsPerTest[testId] = [];
+        ApiActions.logsPerTest[testId].push(message);
+        if (testInfo?.title) {
+            try {
+                UnifiedReportManager.adicionarLog(testInfo.title, message);
+            }
+            catch {
+                // Silenciosamente ignorar
+            }
+        }
+    }
+    /**
+     * ✅ MÉTODO GET: Interface Nova Avançada
+     *
+     * @param request Objeto contendo URL, opções e certificado opcional da requisição
+     * @param descricao Descrição da ação para logs e relatórios
+     * @param ignoreSSL Se true, ignora erros de certificado SSL (mutuamente exclusivo com certificate)
+     * @returns Promise<ApiResponse> - Resposta avançada com métodos especializados
+     *
+     * ⚠️ IMPORTANTE: Não use ignoreSSL=true junto com certificate no request.
+     * Use apenas um dos dois: ignoreSSL OU certificate.
+     */
+    static async get(request, descricao, ignoreSSL = false) {
+        ApiActions.marcarUsoAutomatico();
+        return ApiActions._request('get', request, descricao, ignoreSSL);
+    }
+    /**
+     * ✅ MÉTODO POST: Interface Nova Avançada
+     *
+     * @param request Objeto contendo URL, opções e certificado opcional da requisição
+     * @param descricao Descrição da ação para logs e relatórios
+     * @param ignoreSSL Se true, ignora erros de certificado SSL (mutuamente exclusivo com certificate)
+     * @returns Promise<ApiResponse> - Resposta avançada com métodos especializados
+     *
+     * ⚠️ IMPORTANTE: Não use ignoreSSL=true junto com certificate no request.
+     * Use apenas um dos dois: ignoreSSL OU certificate.
+     */
+    static async post(request, descricao, ignoreSSL = false) {
+        ApiActions.marcarUsoAutomatico();
+        return ApiActions._request('post', request, descricao, ignoreSSL);
+    }
+    /**
+     * ✅ MÉTODO PUT: Interface Nova Avançada
+     *
+     * @param request Objeto contendo URL e opções da requisição
+     * @param descricao Descrição da ação para logs e relatórios
+     * @param ignoreSSL Se true, ignora erros de certificado SSL
+     * @returns Promise<ApiResponse> - Resposta avançada com métodos especializados
+     */
+    static async put(request, descricao, ignoreSSL = false) {
+        ApiActions.marcarUsoAutomatico();
+        return ApiActions._request('put', request, descricao, ignoreSSL);
+    }
+    /**
+     * ✅ MÉTODO PATCH: Interface Nova Avançada
+     *
+     * @param request Objeto contendo URL e opções da requisição
+     * @param descricao Descrição da ação para logs e relatórios
+     * @param ignoreSSL Se true, ignora erros de certificado SSL
+     * @returns Promise<ApiResponse> - Resposta avançada com métodos especializados
+     */
+    static async patch(request, descricao, ignoreSSL = false) {
+        ApiActions.marcarUsoAutomatico();
+        return ApiActions._request('patch', request, descricao, ignoreSSL);
+    }
+    /**
+     * ✅ MÉTODO DELETE: Interface Nova Avançada
+     *
+     * @param request Objeto contendo URL e opções da requisição
+     * @param descricao Descrição da ação para logs e relatórios
+     * @param ignoreSSL Se true, ignora erros de certificado SSL
+     * @returns Promise<ApiResponse> - Resposta avançada com métodos especializados
+     */
+    static async delete(request, descricao, ignoreSSL = false) {
+        ApiActions.marcarUsoAutomatico();
+        return ApiActions._request('delete', request, descricao, ignoreSSL);
+    }
+    /**
+     * ✅ COMPATIBILIDADE: Método especial para registrar duração
+     * @param nome Nome do teste
+     * @param duracao Duração em milissegundos
+     */
+    static registrarDuracaoDoTeste(nome, duracao) {
+        ApiActions.duracoes.push({ nome, duracao });
+    }
+    /**
+     * Cria um objeto FormData para requisições multipart/form-data.
+     * @param fields Campos simples do formulário (chave/valor).
+     * @param files Arquivos para upload, onde o valor pode ser um Buffer ou caminho do arquivo.
+     * @returns Instância de FormData pronta para uso em requisições.
+     */
+    static createFormData(fields, files) {
+        // ESM compat: use createRequire to import CommonJS module synchronously
+        const require = createRequire(import.meta.url);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-var-requires
+        const FormData = require('form-data');
+        const form = new FormData();
+        for (const [key, value] of Object.entries(fields)) {
+            form.append(key, value);
+        }
+        if (files) {
+            for (const [key, value] of Object.entries(files)) {
+                // biome-ignore lint/suspicious/noExplicitAny: FormData.append accepts Buffer|string but typings are from dynamic require
+                form.append(key, value);
+            }
+        }
+        return form;
+    }
+    /**
+     * Cria um contexto de requisição Playwright com certificado de cliente.
+     * @param options Opções para configuração do contexto, incluindo caminhos de certificado, headers, timeout, etc.
+     * @returns Contexto de requisição configurado para autenticação mútua ou SSL customizado.
+     */
+    static async prepareContextWithCert(options) {
+        const clientCertificates = [];
+        if (options.certPath && options.keyPath) {
+            clientCertificates.push({
+                origin: options.origin,
+                certPath: options.certPath,
+                keyPath: options.keyPath,
+                passphrase: options.passphrase,
+            });
+        }
+        else if (options.pfxPath) {
+            clientCertificates.push({
+                origin: options.origin,
+                pfxPath: options.pfxPath,
+                passphrase: options.passphrase,
+            });
+        }
+        return playwrightRequest.newContext({
+            ignoreHTTPSErrors: options.ignoreHTTPSErrors ?? true,
+            clientCertificates,
+            extraHTTPHeaders: options.extraHTTPHeaders,
+            timeout: options.timeout,
+            userAgent: options.userAgent,
+        });
+    }
+    /**
+     * Centraliza execução de requisições HTTP, logs e métricas.
+     * @param method Método HTTP a ser executado (get, post, put, patch, delete).
+     * @param request Objeto contendo a URL e opções da requisição.
+     * @param descricao Descrição da requisição para logs e relatórios.
+     * @param ignoreSSL Se true, ignora erros de certificado SSL.
+     * @returns Resposta padronizada da API.
+     */
+    static async _request(method, request, descricao, ignoreSSL) {
+        // ✅ Validação de URL obrigatória (boundary check)
+        if (!request.url || typeof request.url !== 'string') {
+            throw new ValidationError('AC-API-001', 'URL da requisição é obrigatória e deve ser uma string', 'A URL da requisição não foi informada ou não é uma string válida.');
+        }
+        const trimmedUrl = request.url.trim();
+        if (!/^(https?:\/\/.+|\/)/i.test(trimmedUrl)) {
+            throw new ValidationError('AC-API-001', `URL inválida: "${trimmedUrl}". A URL deve começar com http://, https:// ou / (relativa com baseURL do sistema)`, `A URL informada ("${trimmedUrl}") não é válida. Use http://, https:// ou caminho relativo iniciando com /.`);
+        }
+        ApiActions.marcarUsoAutomatico();
+        // 🆕 Registrar statement no StatementTracker
+        let statementTimestamp = null;
+        try {
+            statementTimestamp = StatementTracker.startStatement('ApiActions', `${method.toUpperCase()}: ${descricao}`);
+        }
+        catch (error) {
+            console.warn('Não foi possível registrar statement no StatementTracker:', error);
+        }
+        // 🚀 LÓGICA INTELIGENTE: Certificados sempre usam SSL bypass
+        const effectiveIgnoreSSL = ignoreSSL || !!request.certificate;
+        // 📡 LOG COM PROTEÇÃO ANTI-DUPLICAÇÃO (via StatementTracker)
+        StatementTracker.logRequest(method, descricao);
+        ApiActions.logEvent(`🔄 Executando ${method.toUpperCase()}: ${descricao}`);
+        const startTime = Date.now();
+        // 📚 CRÍTICO: Interceptar para documentação automática e StatementTracker
+        let docId = null;
+        try {
+            // 🔄 ExecutionTracker - Interceptação CRÍTICA para persistência (CORRIGIDO ESM)
+            try {
+                if (ExecutionTracker) {
+                    const apiCallData = {
+                        id: `api_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                        method: method.toUpperCase(),
+                        url: request.url,
+                        headers: request.options?.headers || {},
+                        payload: request.options?.data || {},
+                        timestamp: new Date().toISOString(),
+                        testName: descricao || 'current-test',
+                        environment: process.env.NODE_ENV || 'test',
+                        success: true, // Will be updated later
+                        statusCode: 0, // Will be updated later
+                        duration: 0, // Will be updated later
+                        response: null, // Will be updated later
+                        error: null,
+                    };
+                    ExecutionTracker.trackAPI(apiCallData);
+                    docId = apiCallData.id;
+                }
+            }
+            catch (trackerError) {
+                console.log(`📚 ExecutionTracker import falhou: ${String(trackerError)}`);
+            }
+            // ✅ REMOVIDO: AutoDocs interceptação duplicada - usando apenas ExecutionTracker
+        }
+        catch (error) {
+            // Log de debug apenas se debug ativo
+            docId = null;
+        }
+        try {
+            // ✅ CORRIGIDO: Obter baseURL ANTES de criar o contexto
+            let baseURL;
+            const isAbsoluteUrl = request.url.startsWith('http://') || request.url.startsWith('https://');
+            // ✅ SEMPRE tentar obter baseURL do AutoCore Hub ANTES de criar contexto
+            if (!isAbsoluteUrl) {
+                try {
+                    const configManager = DynamicConfigManager.getInstance();
+                    const maxAttempts = 10;
+                    const waitIntervalMs = 60;
+                    let hasSystemConfigured = null;
+                    let apiConfig = configManager.getApiConfig();
+                    const waitForSystemConfig = async () => {
+                        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                            try {
+                                hasSystemConfigured = StatementTracker.getCurrentCTSystem();
+                            }
+                            catch {
+                                hasSystemConfigured = null;
+                            }
+                            apiConfig = configManager.getApiConfig();
+                            if (apiConfig?.baseUrl && hasSystemConfigured) {
+                                return;
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, waitIntervalMs * (attempt + 1)));
+                        }
+                    };
+                    // ✅ Esperar sistema ser configurado quando ainda não houver base ou CT estiver desconhecido
+                    if (!apiConfig?.baseUrl) {
+                        console.log('⏳ [AutoCore Hub] Aguardando configuração do sistema (baseUrl indisponível)...');
+                        await waitForSystemConfig();
+                    }
+                    else {
+                        try {
+                            hasSystemConfigured = StatementTracker.getCurrentCTSystem();
+                        }
+                        catch {
+                            hasSystemConfigured = null;
+                        }
+                        if (!hasSystemConfigured) {
+                            await waitForSystemConfig();
+                        }
+                    }
+                    if (apiConfig?.baseUrl) {
+                        // ✅ CORRIGIDO: Remover barra final se existir (Playwright adiciona automaticamente)
+                        baseURL = apiConfig.baseUrl.replace(/\/$/, '');
+                        const resolvedSystem = hasSystemConfigured || 'desconhecido';
+                    }
+                    else {
+                        console.log('⚠️ [AutoCore Hub] Nenhuma configuração de sistema encontrada - usando URL absoluta ou chamada sem setSystem()');
+                    }
+                }
+                catch (error) {
+                    console.log(`⚠️ [AutoCore Hub] Erro ao obter baseURL: ${error}`);
+                }
+            }
+            const context = await ApiActions.prepareContext(effectiveIgnoreSSL, request.certificate, request.url, baseURL);
+            // Validar que URL relativa tenha baseURL resolvido
+            if (!isAbsoluteUrl && !baseURL) {
+                throw new ValidationError('AC-API-002', `URL relativa "${request.url}" requer baseURL. Verifique se o sistema foi configurado via setSystem() e possui URL cadastrada.`, 'Use TestAnnotations.setSystem() antes de chamar ApiActions ou forneça uma URL absoluta (http/https).');
+            }
+            // ✅ LOGS DETALHADOS PARA DEBUG
+            console.log('\n-------------------REQUEST-------------------\n');
+            // 🎯 Mostrar URL completa no log (baseURL + endpoint apenas se não for absoluta)
+            const fullUrl = baseURL && !isAbsoluteUrl
+                ? `${baseURL}${request.url}`
+                : request.url;
+            Logger.info(`ENDPOINT: ${fullUrl}`);
+            Logger.info(`METHOD: ${method.toUpperCase()}`);
+            Logger.info(`IGNORE_SSL: ${ignoreSSL}`);
+            Logger.info(`CONTEXT: ${context ? 'OK' : 'NULL'}`);
+            Logger.info(`CERTIFICATE: ${request.certificate ? 'YES' : 'NO'}`);
+            if (request.options?.headers) {
+                const maskedHeaders = Object.entries(request.options.headers)
+                    .map(([key, value]) => `${key} : ${ApiActions.shouldMaskHeader(key) ? '***' : value}`)
+                    .join('][');
+                Logger.info(`HEADERS: [${maskedHeaders}]`);
+            }
+            if (request.options?.data !== undefined) {
+                const bodyString = typeof request.options.data === 'string'
+                    ? request.options.data
+                    : JSON.stringify(request.options.data);
+                const formattedData = ApiActions.formatAndMaskBody(bodyString);
+                Logger.info(`BODY:\n${formattedData}`);
+            }
+            if (request.options?.form !== undefined) {
+                Logger.info(`FORM (x-www-form-urlencoded): ${JSON.stringify(request.options.form)}`);
+            }
+            // ✅ DIAGNÓSTICO: Validar URL (apenas para URLs absolutas)
+            if (request.url.startsWith('http://') ||
+                request.url.startsWith('https://')) {
+                try {
+                    new URL(request.url); // Validação - lança erro se inválida
+                }
+                catch (urlError) {
+                    console.error(`❌ URL inválida: ${request.url}`);
+                    throw new Error(`URL inválida: ${request.url}`);
+                }
+            }
+            else if (baseURL) {
+                // URL relativa com baseURL - validar a combinação
+                try {
+                    // ✅ CORRIGIDO: Playwright concatena baseURL + endpoint (mantém / inicial do endpoint)
+                    const fullUrlForValidation = `${baseURL}${request.url}`;
+                    new URL(fullUrlForValidation); // Validação - lança erro se inválida
+                }
+                catch (urlError) {
+                    const fullUrl = `${baseURL}${request.url}`;
+                    console.error(`❌ URL inválida após combinar com baseURL: ${fullUrl}`);
+                    throw new Error(`URL inválida: ${fullUrl}`);
+                }
+            }
+            // 🎯 Adicionar params (query parameters) à URL se existirem
+            let finalUrl = request.url;
+            if (request.options?.params) {
+                const queryParams = new URLSearchParams();
+                for (const [key, value] of Object.entries(request.options.params)) {
+                    queryParams.append(key, String(value));
+                }
+                const separator = finalUrl.includes('?') ? '&' : '?';
+                finalUrl = `${finalUrl}${separator}${queryParams.toString()}`;
+                console.log(`🎯 [AutoCore Hub] Query params adicionados: ${queryParams.toString()}`);
+            }
+            // ✅ NOVO: Processar form (x-www-form-urlencoded) se existir
+            const { form: _formField, ...finalOptions } = { ...request.options };
+            if (request.options?.form) {
+                const formData = new URLSearchParams();
+                for (const [key, value] of Object.entries(request.options.form)) {
+                    formData.append(key, String(value));
+                }
+                finalOptions.data = formData.toString();
+                finalOptions.headers = {
+                    ...finalOptions.headers,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                };
+                Logger.info(`📝 [AutoCore Hub] Form convertido para x-www-form-urlencoded: ${formData.toString()}`);
+            }
+            // Executa requisição
+            const response = await context[method](finalUrl, finalOptions);
+            // ✅ VALIDAÇÃO CRÍTICA: Verificar se response é válido
+            if (!response) {
+                Logger.error(`❌ Response é null/undefined para ${method.toUpperCase()} ${finalUrl}`);
+                throw new Error(`Response inválido recebido para ${method.toUpperCase()} ${finalUrl}`);
+            }
+            // ✅ LOG APÓS RECEBER RESPONSE
+            Logger.success(`Response recebida - Status: ${response?.status() || 'UNDEFINED'}`);
+            Logger.success(`Response type: ${typeof response}`);
+            const endTime = Date.now();
+            const duration = endTime - startTime;
+            // ✅ VALIDAÇÃO CRÍTICA: Verificar se métodos existem
+            let responseBody;
+            let statusCode;
+            try {
+                statusCode = response.status();
+                if (typeof statusCode !== 'number') {
+                    Logger.error(`❌ Status code inválido: ${statusCode}`);
+                    statusCode = 500;
+                }
+            }
+            catch (error) {
+                Logger.error(`❌ Erro ao obter status code: ${error}`);
+                statusCode = 500;
+            }
+            try {
+                responseBody = await response.text();
+                if (typeof responseBody !== 'string') {
+                    Logger.error(`❌ Response body inválido: ${typeof responseBody}`);
+                    responseBody = JSON.stringify({ error: 'Invalid response body' });
+                }
+            }
+            catch (error) {
+                Logger.error(`❌ Erro ao obter response body: ${error}`);
+                responseBody = JSON.stringify({
+                    error: 'Failed to read response body',
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+            // 📚 CRÍTICO: Atualizar documentação automática com resposta
+            try {
+                // 🔄 ExecutionTracker - Sistema único de atualização (evita duplicação)
+                if (docId) {
+                    if (ExecutionTracker) {
+                        let responseData = null;
+                        try {
+                            responseData = responseBody
+                                ? JSON.parse(responseBody)
+                                : responseBody;
+                        }
+                        catch {
+                            responseData = responseBody; // Se não for JSON válido, usar como string
+                        }
+                        ExecutionTracker.updateAPIResult(docId, responseData, statusCode);
+                    }
+                }
+                // ✅ REMOVIDO: AutoDocs update duplicado - usando apenas ExecutionTracker
+            }
+            catch (error) {
+                // Log de debug apenas se debug ativo
+                if (process.env.AUTOCORE_DEBUG_LOGS === 'true') {
+                    console.log(`📚 AutoDocs update falhou: ${String(error)}`);
+                }
+            }
+            // Log da resposta
+            console.log('\n-------------------RESPONSE-------------------\n');
+            Logger.info(`STATUS CODE: ${statusCode}`);
+            const responseHeaders = response.headers();
+            const maskedResponseHeaders = Object.entries(responseHeaders)
+                .map(([key, value]) => `${key} : ${ApiActions.shouldMaskHeader(key) ? '***' : value}`)
+                .join('][');
+            Logger.info(`HEADERS: [${maskedResponseHeaders}]`);
+            const formattedBody = ApiActions.formatAndMaskBody(responseBody);
+            Logger.info(`BODY:\n${formattedBody}`);
+            ApiActions.requestCount++;
+            if (statusCode >= 200 && statusCode < 300) {
+                ApiActions.successCount++;
+                ApiActions.logTestResult(descricao, true, duration);
+            }
+            else {
+                ApiActions.failureCount++;
+                ApiActions.logTestResult(descricao, false, duration);
+            }
+            const apiResponse = ApiActions.createApiResponse(statusCode, responseHeaders, responseBody, duration);
+            // 📝 NOVO: Registrar ação automaticamente no Statement ativo COM LOGS COMPLETOS
+            try {
+                // 🆕 Preparar request headers mascarados
+                const maskedReqHeaders = {};
+                if (request.options?.headers) {
+                    for (const [key, value] of Object.entries(request.options.headers)) {
+                        maskedReqHeaders[key] = ApiActions.shouldMaskHeader(key) ? '***' : String(value);
+                    }
+                }
+                // 🆕 Preparar request body
+                const reqBody = request.options?.data !== undefined
+                    ? (typeof request.options.data === 'string'
+                        ? request.options.data
+                        : JSON.stringify(request.options.data, null, 2))
+                    : request.options?.form !== undefined
+                        ? JSON.stringify(request.options.form)
+                        : undefined;
+                // 🆕 Preparar response headers mascarados
+                const maskedRespHeaders = {};
+                for (const [key, value] of Object.entries(responseHeaders)) {
+                    maskedRespHeaders[key] = ApiActions.shouldMaskHeader(key) ? '***' : String(value);
+                }
+                StatementTracker.recordAction('API', `${method.toUpperCase()} ${request.url}`, statusCode >= 200 && statusCode < 300, duration, {
+                    method: method.toUpperCase(),
+                    url: request.url,
+                    statusCode,
+                    // 🆕 Logs completos de API
+                    requestHeaders: maskedReqHeaders,
+                    requestBody: ApiActions.formatAndMaskBody(reqBody || ''),
+                    responseHeaders: maskedRespHeaders,
+                    responseBody: ApiActions.formatAndMaskBody(responseBody),
+                });
+            }
+            catch (error) {
+                // Falha silenciosa - não afetar funcionalidade principal
+            }
+            // 🆕 Finalizar statement com sucesso
+            if (statementTimestamp) {
+                try {
+                    const success = statusCode >= 200 && statusCode < 300;
+                    const statusMessage = success
+                        ? `✅ ${method.toUpperCase()} ${descricao}: ${statusCode} (${duration}ms)`
+                        : `⚠️ ${method.toUpperCase()} ${descricao}: ${statusCode} (${duration}ms)`;
+                    StatementTracker.finishStatement(statementTimestamp, success, statusMessage);
+                }
+                catch (error) {
+                    console.warn('Não foi possível finalizar statement no StatementTracker:', error);
+                }
+            }
+            return apiResponse;
+        }
+        catch (error) {
+            const endTime = Date.now();
+            const duration = endTime - startTime;
+            // 🔐 FALLBACK PROGRESSIVO: Se erro de certificado e existe certificado, tentar outras estratégias
+            if (error instanceof Error &&
+                request.certificate &&
+                (error.message.includes('mac verify failure') ||
+                    error.message.includes('certificate verify failed') ||
+                    error.message.includes('ssl routines') ||
+                    error.message.includes('SSL') ||
+                    error.message.includes('TLS'))) {
+                console.warn(`🔐 SSL ERROR DETECTADO: ${error.message}`);
+                console.warn('🚀 FALLBACK PROGRESSIVO: Tentando outras estratégias de certificado...');
+                try {
+                    // ✅ NOVO: Tentar próximas estratégias ordenadas por eficácia (SEM PROXY primeiro)
+                    const fallbackStrategies = [
+                        {
+                            name: 'SEM PROXY',
+                            useProxy: false,
+                            ignoreSSL: true,
+                            certificate: true,
+                            specialHeaders: false,
+                        },
+                        {
+                            name: 'COMPLETO',
+                            useProxy: true,
+                            ignoreSSL: true,
+                            certificate: true,
+                            specialHeaders: false,
+                        },
+                        {
+                            name: 'SEM HEADERS',
+                            useProxy: true,
+                            ignoreSSL: true,
+                            certificate: true,
+                            specialHeaders: false,
+                        },
+                        {
+                            name: 'SSL ONLY',
+                            useProxy: false,
+                            ignoreSSL: true,
+                            certificate: false,
+                            specialHeaders: false,
+                        },
+                        {
+                            name: 'FALLBACK',
+                            useProxy: false,
+                            ignoreSSL: true,
+                            certificate: false,
+                            specialHeaders: false,
+                        },
+                        {
+                            name: 'PADRÃO',
+                            useProxy: false,
+                            ignoreSSL: false,
+                            certificate: false,
+                            specialHeaders: false,
+                        },
+                    ];
+                    let fallbackSuccess = false;
+                    for (const strategy of fallbackStrategies) {
+                        console.log(`🔄 FALLBACK: Tentando estratégia ${strategy.name}...`);
+                        try {
+                            const fallbackContext = await ApiActions.tryProgressiveStrategy(strategy, request.certificate, request.url, 'http://proxy.redecorp.br:8080');
+                            if (fallbackContext) {
+                                console.log(`🔄 Executando requisição com estratégia ${strategy.name}...`);
+                                const fallbackResponse = await fallbackContext[method](request.url, request.options);
+                                if (!fallbackResponse) {
+                                    throw new Error(`Response inválido recebido para ${method.toUpperCase()} ${request.url}`);
+                                }
+                                const fallbackStatusCode = fallbackResponse.status();
+                                const fallbackHeaders = await fallbackResponse.headers();
+                                const fallbackBody = await fallbackResponse.text();
+                                const fallbackEndTime = Date.now();
+                                const fallbackDuration = fallbackEndTime - startTime;
+                                console.log(`✅ FALLBACK FUNCIONOU! Estratégia ${strategy.name} - Status: ${fallbackStatusCode} em ${fallbackDuration}ms`);
+                                fallbackSuccess = true;
+                                return ApiActions.createApiResponse(fallbackStatusCode, fallbackHeaders, fallbackBody, fallbackDuration);
+                            }
+                        }
+                        catch (strategyError) {
+                            console.log(`❌ Estratégia ${strategy.name} falhou: ${strategyError instanceof Error ? strategyError.message : String(strategyError)}`);
+                        }
+                    }
+                    if (!fallbackSuccess) {
+                        throw new Error('Todas as estratégias de fallback falharam');
+                    }
+                }
+                catch (fallbackError) {
+                    console.error(`❌ FALLBACK PROGRESSIVO também falhou: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
+                    // Continuar com erro original
+                }
+            }
+            // ✅ DIAGNÓSTICO DETALHADO: Log completo do erro
+            console.error('\n-------------------ERROR DETAILS-------------------');
+            console.error(`❌ Erro durante ${method.toUpperCase()} para ${request.url}`);
+            console.error(`❌ Tipo do erro: ${error instanceof Error ? error.constructor.name : typeof error}`);
+            console.error(`❌ Mensagem: ${error instanceof Error ? error.message : String(error)}`);
+            console.error(`❌ Stack: ${error instanceof Error ? error.stack : 'N/A'}`);
+            console.error(`❌ Duração até falha: ${duration}ms`);
+            console.error(`❌ Certificado usado: ${request.certificate ? 'SIM' : 'NÃO'}`);
+            console.error(`❌ SSL bypass aplicado: ${effectiveIgnoreSSL}`);
+            console.error('---------------------------------------------------\n');
+            // 📚 CRÍTICO: Atualizar documentação automática com erro
+            try {
+                // 🔄 ExecutionTracker - Sistema único de atualização (evita duplicação)
+                if (docId) {
+                    if (ExecutionTracker) {
+                        ExecutionTracker.updateAPIResult(docId, {
+                            error: true,
+                            message: error instanceof Error ? error.message : String(error),
+                        }, 500, error);
+                    }
+                }
+            }
+            catch (updateError) {
+                // Log de debug apenas se debug ativo
+                if (process.env.AUTOCORE_DEBUG_LOGS === 'true') {
+                    console.log(`📚 AutoDocs error update falhou: ${String(updateError)}`);
+                }
+            }
+            ApiActions.failureCount++;
+            ApiActions.logTestResult(descricao, false, duration);
+            // 🎯 NOVO: Criar erro especializado com base no tipo da falha
+            let apiError;
+            if (error instanceof Error) {
+                // Verificar tipo específico do erro
+                if (error.message.includes('net::ERR_') ||
+                    error.message.includes('ECONNREFUSED') ||
+                    error.message.includes('ETIMEDOUT')) {
+                    // Erro de rede
+                    apiError = IntegrationError.networkError(request.url, error, {
+                        metadata: {
+                            method: method.toUpperCase(),
+                            description: descricao,
+                            duration,
+                            ignoreSSL,
+                        },
+                    });
+                }
+                else if (error.message.includes('timeout')) {
+                    // Erro de timeout
+                    apiError = IntegrationError.timeoutError(`${method.toUpperCase()} ${request.url}`, 30_000, {
+                        metadata: {
+                            method: method.toUpperCase(),
+                            description: descricao,
+                            duration,
+                            url: request.url,
+                        },
+                    });
+                }
+                else if (error.message.includes('Invalid URL') ||
+                    error.message.includes('Protocol')) {
+                    // Erro de URL inválida
+                    apiError = ValidationError.invalidUrl(request.url, error.message, {
+                        metadata: {
+                            method: method.toUpperCase(),
+                            description: descricao,
+                        },
+                    });
+                }
+                else {
+                    // Erro genérico de API
+                    apiError = IntegrationError.apiRequestFailed(request.url, 0, error.message, {
+                        metadata: {
+                            method: method.toUpperCase(),
+                            description: descricao,
+                            duration,
+                            originalError: error.message,
+                        },
+                    });
+                }
+            }
+            else {
+                // Erro desconhecido
+                apiError = IntegrationError.apiRequestFailed(request.url, 0, String(error), {
+                    metadata: {
+                        method: method.toUpperCase(),
+                        description: descricao,
+                        duration,
+                        originalError: String(error),
+                    },
+                });
+            }
+            // 📝 Log do erro especializado
+            Logger.error(`❌ ${apiError.getUserFriendlyMessage()}`);
+            ApiActions.logEvent(`❌ ${apiError.userMessage}`);
+            // ✅ CRÍTICO: SEMPRE retornar ApiResponse válida com informações úteis do erro
+            const errorResponse = ApiActions.createApiResponse(500, {}, JSON.stringify({
+                error: true,
+                code: apiError.code,
+                message: apiError.userMessage,
+                type: 'API_REQUEST_FAILED',
+                details: apiError.message,
+                suggestions: apiError.suggestions,
+                errorId: apiError.id,
+                timestamp: apiError.timestamp,
+                recoverable: apiError.recoverable,
+            }), duration);
+            // 📝 NOVO: Registrar ação com falha no Statement ativo
+            try {
+                StatementTracker.recordAction('API', `${method.toUpperCase()} ${request.url}`, false, duration, {
+                    method: method.toUpperCase(),
+                    url: request.url,
+                    statusCode: 500,
+                });
+            }
+            catch (error) {
+                // Falha silenciosa - não afetar funcionalidade principal
+            }
+            // 🆕 Finalizar statement com erro
+            if (statementTimestamp) {
+                try {
+                    StatementTracker.finishStatement(statementTimestamp, false, `❌ ${method.toUpperCase()} ${descricao}: ${apiError.userMessage}`);
+                }
+                catch (error) {
+                    console.warn('Não foi possível finalizar statement no StatementTracker:', error);
+                }
+            }
+            Logger.info(`🔧 Retornando ApiResponse com erro estruturado - ID: ${apiError.id}`);
+            return errorResponse;
+        }
+    }
+    static logTestResult(descricao, success, duration) {
+        const timestamp = new Date().toLocaleTimeString('pt-BR', {
+            hour12: false,
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            fractionalSecondDigits: 3,
+        });
+        const status = success ? 'PASSED' : 'FAILED';
+        const statusIcon = success ? '✅' : '❌';
+        Logger.info(`[ STEP ] ${descricao} [ ${status} ] `);
+        console.log('');
+        const logMessage = `${statusIcon} ${descricao} - ${status} (${duration}ms)`;
+        const testInfo = TestContext.getSafeTestInfo();
+        const testId = testInfo?.title || 'global';
+        if (!ApiActions.logsPerTest[testId])
+            ApiActions.logsPerTest[testId] = [];
+        ApiActions.logsPerTest[testId].push(logMessage);
+        if (testInfo?.title) {
+            try {
+                UnifiedReportManager.adicionarLog(testInfo.title, logMessage);
+            }
+            catch {
+                // Silenciosamente ignorar
+            }
+        }
+    }
+    /**
+     * Valida se dois valores são iguais.
+     * Registra sucesso ou falha nos logs e incrementa métricas.
+     * Lança erro se os valores não forem iguais.
+     * @param actual Valor atual obtido.
+     * @param expected Valor esperado.
+     * @param message Mensagem descritiva da validação.
+     * @throws {ValidationError} Se os valores não forem iguais.
+     */
+    static validateEquals(actual, expected, message) {
+        ApiActions.marcarUsoAutomatico();
+        const timestamp = new Date().toLocaleTimeString('pt-BR', {
+            hour12: false,
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            fractionalSecondDigits: 3,
+        });
+        if (actual === expected) {
+            ApiActions.successCount++;
+            const successMessage = `✅ Validação passou: ${message} (${actual} === ${expected})`;
+            ApiActions.logEvent(successMessage);
+            Logger.success(`Validação passou: ${message}`);
+        }
+        else {
+            ApiActions.failureCount++;
+            console.log(`${timestamp}`);
+            console.log(`[ STEP ] ${message} [ FAILED ] `);
+            const errorMessage = `❌ Validação falhou: ${message} (${actual} !== ${expected})`;
+            ApiActions.logEvent(errorMessage);
+            Logger.error(`Validação falhou: ${message} - Esperado: ${expected}, Atual: ${actual}`);
+            throw new ValidationError('API_VALIDATION_FAILED', `Validation failed: ${message} - Expected: ${expected}, Actual: ${actual}`, `Validação falhou: ${message} - Esperado: ${expected}, Atual: ${actual}`, undefined, { metadata: { expected, actual, context: message } });
+        }
+    }
+    /**
+     * Valida se um valor não é nulo ou undefined.
+     * Registra sucesso ou falha nos logs e incrementa métricas.
+     * Lança erro se o valor for nulo ou undefined.
+     * @param value Valor a ser validado.
+     * @param message Mensagem descritiva da validação.
+     * @throws {ValidationError} Se o valor for nulo ou undefined.
+     */
+    static validateNotNull(value, message) {
+        ApiActions.marcarUsoAutomatico();
+        if (value != null && value !== undefined) {
+            ApiActions.successCount++;
+            const successMessage = `✅ Validação passou: ${message} (valor não é nulo)`;
+            ApiActions.logEvent(successMessage);
+            Logger.success(`Validação passou: ${message}`);
+        }
+        else {
+            ApiActions.failureCount++;
+            const errorMessage = `❌ Validação falhou: ${message} (valor é nulo/undefined)`;
+            ApiActions.logEvent(errorMessage);
+            Logger.error(`❌ Validação falhou: ${message} - Valor é nulo ou undefined`);
+            throw new ValidationError('API_NULL_VALUE', `Validation failed: ${message} - Value is null or undefined`, `Validação falhou: ${message} - Valor é nulo ou undefined`, undefined, { metadata: { value, context: message } });
+        }
+    }
+    static maskSensitiveDataInBody(body) {
+        if (!body)
+            return body;
+        try {
+            const maskedBody = body
+                .replace(/"access_token":\s*"[^"]+"/g, '"access_token":"***"')
+                .replace(/"password":\s*"[^"]+"/g, '"password":"***"')
+                .replace(/password=[^&\s]+/g, 'password=***')
+                .replace(/token=[^&\s]+/g, 'token=***');
+            return maskedBody;
+        }
+        catch {
+            return body;
+        }
+    }
+    /**
+     * 🎨 Formata e mascara corpo JSON para exibição legível
+     * @param body String contendo JSON ou texto
+     * @returns JSON formatado com indentação ou texto original
+     */
+    static formatAndMaskBody(body) {
+        if (!body)
+            return body;
+        try {
+            // Tenta fazer parse como JSON
+            const parsed = JSON.parse(body);
+            // Converte para JSON formatado com indentação
+            let formatted = JSON.stringify(parsed, null, 2);
+            // Aplica mascaramento de dados sensíveis
+            formatted = formatted
+                .replace(/"access_token":\s*"[^"]+"/g, '"access_token": "***"')
+                .replace(/"password":\s*"[^"]+"/g, '"password": "***"')
+                .replace(/"token":\s*"[^"]+"/g, '"token": "***"')
+                .replace(/"senha":\s*"[^"]+"/g, '"senha": "***"');
+            return formatted;
+        }
+        catch {
+            // Se não for JSON válido, aplica mascaramento básico e retorna
+            return ApiActions.maskSensitiveDataInBody(body);
+        }
+    }
+    /**
+     * 🔧 Normaliza URL removendo barras duplicadas na junção baseURL + endpoint
+     * @param baseURL URL base (pode terminar com /)
+     * @param endpoint Caminho do endpoint (pode começar com /)
+     * @returns URL completa sem barras duplicadas
+     */
+    static normalizeUrl(baseURL, endpoint) {
+        const cleanBase = baseURL.replace(/\/+$/, ''); // Remove trailing slashes
+        const cleanPath = endpoint.replace(/^\/+/, ''); // Remove leading slashes
+        return `${cleanBase}/${cleanPath}`;
+    }
+    /**
+     * ✅ NOVO: Obtém o timeout do projeto Playwright ou usa padrão
+     */
+    static tryParseJson(text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    /**
+     * ✅ NOVO: Método utilitário para resolver caminho do certificado
+     */
+    static resolveCertPath(certName) {
+        // Se já tem path completo, usar direto
+        if (certName.startsWith('/') || certName.includes(':')) {
+            return certName;
+        }
+        // ✅ CORRIGIDO: Usar createRequire ao invés de require direto
+        const require = createRequire(import.meta.url);
+        const path = require('path');
+        return path.resolve(process.cwd(), certName);
+    }
+    /**
+     * ✅ NOVO: Executa uma tentativa específica da estratégia progressiva
+     */
+    static async tryProgressiveStrategy(strategy, certificate, requestUrl, proxyUrl) {
+        const origin = requestUrl ? new URL(requestUrl).origin : 'https://localhost';
+        // ✅ CORRIGIDO: Só obter baseURL do AutoCore Hub se o CT atual tem sistema configurado E a URL for relativa
+        let baseURL;
+        const isAbsoluteUrl = requestUrl &&
+            (requestUrl.startsWith('http://') || requestUrl.startsWith('https://'));
+        // ✅ NOVO: Obter sistema do CT atual via StatementTracker
+        let hasSystemConfigured = null;
+        try {
+            hasSystemConfigured = StatementTracker.getCurrentCTSystem();
+        }
+        catch {
+            // Ignora se não conseguir importar
+        }
+        if (!isAbsoluteUrl && hasSystemConfigured) {
+            try {
+                const configManager = DynamicConfigManager.getInstance();
+                const apiConfig = configManager.getApiConfig();
+                if (apiConfig && apiConfig.baseUrl) {
+                    // ✅ CORRIGIDO: Remover barra final se existir (Playwright adiciona automaticamente)
+                    baseURL = apiConfig.baseUrl.replace(/\/$/, '');
+                }
+            }
+            catch {
+                // Ignora se não conseguir importar
+            }
+        }
+        // Configurar opções base
+        const contextOptions = {
+            baseURL, // ✅ NOVO: baseURL do sistema selecionado
+            ignoreHTTPSErrors: strategy.ignoreSSL,
+            timeout: TestContext.getProjectTimeout(),
+            extraHTTPHeaders: strategy.specialHeaders
+                ? {
+                    'User-Agent': 'AutoCore-Progressive-Client/1.0',
+                    Accept: 'application/json, text/plain, */*',
+                    'Cache-Control': 'no-cache',
+                    'X-AutoCore-Strategy': strategy.name,
+                    'X-Request-ID': `autocore-${Date.now()}`,
+                }
+                : {
+                    'User-Agent': 'AutoCore-Client/1.0',
+                    Accept: 'application/json, text/plain, */*',
+                },
+        };
+        // Adicionar proxy se solicitado
+        if (strategy.useProxy && proxyUrl) {
+            contextOptions.proxy = {
+                server: proxyUrl,
+            };
+        }
+        // Adicionar certificado se solicitado
+        if (strategy.certificate) {
+            const certPath = ApiActions.resolveCertPath(certificate.name);
+            if (certificate.name.toLowerCase().endsWith('.p12') ||
+                certificate.name.toLowerCase().endsWith('.pfx')) {
+                // NOVO: Para P12/PFX - tentar múltiplas senhas em ordem (password por último)
+                const passwordAttempts = [
+                    certificate.password || '', // Senha fornecida ou string vazia
+                    '', // Sem senha (string vazia)
+                    undefined, // Sem senha (undefined)
+                    'password', // Senha padrão como ÚLTIMA tentativa
+                ].filter((p, index, arr) => arr.indexOf(p) === index); // Remove duplicatas
+                // Tentar cada senha até uma funcionar - SE QUALQUER FALHAR, LANÇAR ERRO PARA TENTAR PRÓXIMA ESTRATÉGIA
+                let lastError = null;
+                for (const attemptPassword of passwordAttempts) {
+                    try {
+                        contextOptions.clientCertificates = [
+                            {
+                                origin,
+                                pfxPath: certPath,
+                                passphrase: attemptPassword === '' ? undefined : attemptPassword,
+                            },
+                        ];
+                        // Criar contexto de teste apenas para verificar se a senha funciona
+                        const testContext = await playwrightRequest.newContext(contextOptions);
+                        await testContext.dispose(); // Limpar contexto de teste
+                        break; // Sair do loop se a senha funcionou
+                    }
+                    catch (passwordError) {
+                        const errorMsg = passwordError instanceof Error
+                            ? passwordError.message
+                            : String(passwordError);
+                        let passwordDesc = '';
+                        if (attemptPassword === '') {
+                            passwordDesc = '(vazia)';
+                        }
+                        else if (attemptPassword === undefined) {
+                            passwordDesc = '(undefined)';
+                        }
+                        else {
+                            passwordDesc = "'" + attemptPassword + "'";
+                        }
+                        console.log('Senha ' +
+                            passwordDesc +
+                            ' falhou: ' +
+                            errorMsg.substring(0, 50) +
+                            '...');
+                        lastError =
+                            passwordError instanceof Error
+                                ? passwordError
+                                : new Error(String(passwordError));
+                    }
+                }
+                // Se todas as senhas falharam, lançar erro para tentar próxima estratégia
+                if (lastError) {
+                    throw new Error('Todas as senhas falharam para estrategia ' +
+                        strategy.name +
+                        ': ' +
+                        lastError.message);
+                }
+            }
+            else {
+                // Para PEM (se tiver keyPath)
+                if (certificate.keyPath) {
+                    contextOptions.clientCertificates = [
+                        {
+                            origin,
+                            certPath,
+                            keyPath: certificate.keyPath,
+                            passphrase: certificate.password || undefined,
+                        },
+                    ];
+                }
+            }
+        }
+        // Tentar criar contexto
+        try {
+            const context = await playwrightRequest.newContext(contextOptions);
+            // ✅ CORREÇÃO: Não fazer teste de conectividade para evitar interferência com AutoDocs
+            // O contexto será testado na requisição real do usuário
+            return context;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.log('Falha ao criar contexto:', errorMsg);
+            throw error;
+        }
+    }
+    static async prepareContext(ignoreSSL = false, certificate, requestUrl, baseURL) {
+        if (certificate) {
+            // SISTEMA PROGRESSIVO: Múltiplas tentativas do mais completo ao mais simples
+            const corporateProxy = process.env.PROXY_URL || 'http://proxy.redecorp.br:8080';
+            // TENTATIVAS PROGRESSIVAS: 10 estratégias ordenadas por eficácia comprovada
+            const strategies = [
+                // 1. SEM PROXY: COMPROVADAMENTE EFICAZ - Certificado + SSL bypass (sem proxy)
+                {
+                    name: 'SEM PROXY',
+                    useProxy: false,
+                    ignoreSSL: true,
+                    certificate: true,
+                    specialHeaders: false,
+                },
+                // 2. MÁXIMO: Certificado + Proxy + SSL bypass + Headers especiais
+                {
+                    name: 'MÁXIMO',
+                    useProxy: true,
+                    ignoreSSL: true,
+                    certificate: true,
+                    specialHeaders: true,
+                },
+                // 3. COMPLETO: Certificado + Proxy + SSL bypass
+                {
+                    name: 'COMPLETO',
+                    useProxy: true,
+                    ignoreSSL: true,
+                    certificate: true,
+                    specialHeaders: false,
+                },
+                // 4. SEM HEADERS: Certificado + Proxy + SSL bypass (sem headers especiais)
+                {
+                    name: 'SEM HEADERS',
+                    useProxy: true,
+                    ignoreSSL: true,
+                    certificate: true,
+                    specialHeaders: false,
+                },
+                // 5. SSL ONLY: Apenas SSL bypass (sem proxy nem certificado)
+                {
+                    name: 'SSL ONLY',
+                    useProxy: false,
+                    ignoreSSL: true,
+                    certificate: false,
+                    specialHeaders: false,
+                },
+                // 6. PROXY ONLY: Apenas Proxy + SSL bypass (sem certificado)
+                {
+                    name: 'PROXY ONLY',
+                    useProxy: true,
+                    ignoreSSL: true,
+                    certificate: false,
+                    specialHeaders: false,
+                },
+                // 7. CERTIFICADO SIMPLES: Certificado sem extras
+                {
+                    name: 'CERT SIMPLES',
+                    useProxy: false,
+                    ignoreSSL: false,
+                    certificate: true,
+                    specialHeaders: false,
+                },
+                // 8. PROXY SIMPLES: Proxy sem SSL bypass
+                {
+                    name: 'PROXY SIMPLES',
+                    useProxy: true,
+                    ignoreSSL: false,
+                    certificate: false,
+                    specialHeaders: false,
+                },
+                // 9. FALLBACK MÍNIMO: SSL bypass básico
+                {
+                    name: 'FALLBACK',
+                    useProxy: false,
+                    ignoreSSL: true,
+                    certificate: false,
+                    specialHeaders: false,
+                },
+                // 10. PADRÃO: Contexto básico sem nada
+                {
+                    name: 'PADRÃO',
+                    useProxy: false,
+                    ignoreSSL: false,
+                    certificate: false,
+                    specialHeaders: false,
+                },
+            ];
+            for (let i = 0; i < strategies.length; i++) {
+                const strategy = strategies[i];
+                try {
+                    const context = await ApiActions.tryProgressiveStrategy(strategy, certificate, requestUrl, corporateProxy);
+                    if (context) {
+                        return context;
+                    }
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    console.log('Falha na tentativa ' +
+                        (i + 1) +
+                        ': ' +
+                        errorMsg.substring(0, 100) +
+                        '...');
+                    // Se for erro crítico, pular para estratégias mais simples
+                    if (errorMsg.includes('certificate') || errorMsg.includes('proxy')) {
+                        console.log('Erro relacionado a certificado/proxy - continuando...');
+                    }
+                }
+            }
+            // Se chegamos aqui, todas as estratégias falharam
+            console.error('TODAS as 10 estrategias falharam para:', certificate.name);
+            console.warn('Continuando com contexto padrão sem certificado...');
+        }
+        // Contexto padrão sem certificado (com controle SSL configurável)
+        // ✅ CORRIGIDO: Incluir baseURL E sistema na chave do cache para evitar reutilização entre CTs
+        // Obter sistema do CT atual para incluir na chave
+        let currentSystem = 'nosystem';
+        try {
+            const systemFromCT = StatementTracker.getCurrentCTSystem();
+            if (systemFromCT) {
+                currentSystem = systemFromCT;
+            }
+        }
+        catch {
+            // Ignora se não conseguir obter sistema
+        }
+        const cacheKey = 'ssl_' + ignoreSSL + '_' + (certificate ? 'cert' : 'nocert') + '_base_' + (baseURL || 'none') + '_sys_' + currentSystem;
+        if (ApiActions.contextCache.has(cacheKey)) {
+            return ApiActions.contextCache.get(cacheKey);
+        }
+        // ✅ SEM CERTIFICADO: SSL configurável via variável de ambiente ou parâmetro
+        const shouldIgnoreSSL = process.env.IGNORE_SSL_ERRORS === 'true' || ignoreSSL;
+        let sslSource = 'parâmetro';
+        if (certificate) {
+            sslSource = 'certificado automático';
+        }
+        else if (process.env.IGNORE_SSL_ERRORS === 'true') {
+            sslSource = 'IGNORE_SSL_ERRORS=true';
+        }
+        console.log('Configuracao SSL: ' +
+            (shouldIgnoreSSL ? 'DESABILITADA' : 'HABILITADA') +
+            ' (via ' +
+            sslSource +
+            ')');
+        // ✅ CORRIGIDO: Usar baseURL do parâmetro (já foi calculado em _request)
+        const context = await playwrightRequest.newContext({
+            baseURL, // ✅ baseURL do sistema selecionado (apenas para URLs relativas e se setSystem() foi chamado)
+            ignoreHTTPSErrors: shouldIgnoreSSL,
+            timeout: TestContext.getProjectTimeout(),
+            extraHTTPHeaders: {
+                'User-Agent': 'AutoCore-Client/1.0',
+                Accept: 'application/json, text/plain, */*',
+                'Cache-Control': 'no-cache',
+            },
+        });
+        ApiActions.contextCache.set(cacheKey, context);
+        return context;
+    }
+    /**
+     * ✅ ESTRATÉGIA FINAL: SSL Bypass completo para ambientes QA
+     * @param requestUrl URL da requisição (opcional)
+     * @returns Contexto com SSL completamente desabilitado
+     */
+    static async createSSLBypassContext(requestUrl) {
+        try {
+            console.log('🔓 Criando contexto SSL bypass para ambiente QA');
+            // ✅ FORÇAR SSL bypass sempre em ambientes QA
+            const isQAEnvironment = process.env.NODE_ENV === 'qa' ||
+                process.env.NODE_ENV === 'test' ||
+                (requestUrl &&
+                    (requestUrl.includes('qa') || requestUrl.includes('test')));
+            if (!isQAEnvironment) {
+                console.warn('⚠️ SSL Bypass solicitado em ambiente não-QA - usando configuração padrão');
+            }
+            const context = await playwrightRequest.newContext({
+                ignoreHTTPSErrors: true, // ✅ SEMPRE ignorar SSL em bypass
+                timeout: TestContext.getProjectTimeout(),
+                // ✅ NOVO: Proxy corporativo para SSL bypass com certificados
+                proxy: {
+                    server: process.env.PROXY_URL || 'http://proxy.redecorp.br:8080',
+                },
+                extraHTTPHeaders: {
+                    'User-Agent': 'AutoCore-QA-Client/1.0',
+                    Accept: 'application/json, text/plain, */*',
+                    'Cache-Control': 'no-cache',
+                    'X-QA-Environment': 'ssl-bypass',
+                },
+            });
+            console.log('Contexto SSL bypass criado com sucesso');
+            console.log('Ambiente detectado: ' + (isQAEnvironment ? 'QA' : 'Outro'));
+            return context;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error('Falha ao criar contexto SSL bypass:', errorMessage);
+            throw new Error('SSL bypass falhou: ' + errorMessage);
+        }
+    }
+    /**
+     * ✅ NOVA ESTRATÉGIA 1: Usar P12 diretamente com clientCertificates (CORRIGIDO ESM)
+     * @param certificate Certificado P12
+     * @param requestUrl URL da requisição para determinar origem
+     * @returns Contexto configurado com certificado P12 direto
+     */
+    static async tryDirectP12Strategy(certificate, requestUrl) {
+        try {
+            console.log('Configurando P12 direto com clientCertificates:', certificate.name);
+            // ✅ CORRIGIDO: Usar createRequire ao invés de require direto
+            const require = createRequire(import.meta.url);
+            const fs = require('fs');
+            const certPath = ApiActions.resolveCertPath(certificate.name);
+            // Verificar se arquivo existe
+            if (!fs.existsSync(certPath)) {
+                throw new Error('Arquivo P12 nao encontrado: ' + certPath);
+            }
+            // ✅ MÚLTIPLAS TENTATIVAS DE SENHA (password por último como sugerido)
+            const passwordAttempts = [
+                certificate.password || '', // Senha fornecida ou string vazia
+                '', // Sem senha (string vazia)
+                undefined, // Sem senha (undefined)
+                'password', // Senha padrão como ÚLTIMA tentativa
+            ].filter((p, index, arr) => arr.indexOf(p) === index); // Remove duplicatas
+            let context = null;
+            for (const attemptPassword of passwordAttempts) {
+                try {
+                    let passwordDesc = '(fornecida)';
+                    if (attemptPassword === '') {
+                        passwordDesc = '(vazia)';
+                    }
+                    else if (attemptPassword === undefined) {
+                        passwordDesc = '(undefined)';
+                    }
+                    console.log('Tentando P12 direto com senha:', passwordDesc);
+                    const origin = requestUrl
+                        ? new URL(requestUrl).origin
+                        : 'https://api-qa1.telefonica.com.br';
+                    context = await playwrightRequest.newContext({
+                        ignoreHTTPSErrors: true, // ✅ IGNORAR SSL EM QA SEMPRE
+                        timeout: TestContext.getProjectTimeout(),
+                        clientCertificates: [
+                            {
+                                origin,
+                                pfxPath: certPath,
+                                passphrase: attemptPassword === undefined ? undefined : attemptPassword,
+                            },
+                        ],
+                        // ✅ NOVO: Proxy corporativo automático para certificados
+                        proxy: {
+                            server: process.env.PROXY_URL || 'http://proxy.redecorp.br:8080',
+                        },
+                        extraHTTPHeaders: {
+                            'User-Agent': 'AutoCore-Client/1.0',
+                            Accept: 'application/json, text/plain, */*',
+                            'Cache-Control': 'no-cache',
+                        },
+                    });
+                    let passwordDesc2 = '(fornecida)';
+                    if (attemptPassword === '') {
+                        passwordDesc2 = '(vazia)';
+                    }
+                    else if (attemptPassword === undefined) {
+                        passwordDesc2 = '(undefined)';
+                    }
+                    console.log('P12 direto configurado com sucesso usando senha:', passwordDesc2);
+                    console.log(`📍 Origin configurado: ${origin}`);
+                    return context;
+                }
+                catch (passwordError) {
+                    const errorMsg = passwordError instanceof Error
+                        ? passwordError.message
+                        : String(passwordError);
+                    let passwordDesc3 = '(fornecida)';
+                    if (attemptPassword === '') {
+                        passwordDesc3 = '(vazia)';
+                    }
+                    else if (attemptPassword === undefined) {
+                        passwordDesc3 = '(undefined)';
+                    }
+                    console.log('P12 direto falhou com senha ' + passwordDesc3 + ':', errorMsg);
+                    if (context) {
+                        await context.dispose();
+                        context = null;
+                    }
+                }
+            }
+            throw new Error('P12 direto falhou com todas as tentativas de senha');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`❌ Falha na estratégia P12 direto: ${errorMessage}`);
+            throw new Error(`P12 direto falhou: ${errorMessage}`);
+        }
+    }
+    /**
+     * ✅ NOVO: Extrai certificado e chave privada de arquivo P12/PKCS12 usando node-forge
+     * @param p12Path Caminho para o arquivo P12/PKCS12
+     * @param password Senha do arquivo P12 (opcional - deixar vazio se não tiver senha)
+     * @returns Objeto com certificado e chave privada em formato PEM
+     */
+    static extractP12Certificate(p12Path, password) {
+        try {
+            console.log('Extraindo certificado P12:', p12Path);
+            // ✅ CORRIGIDO: Usar createRequire para importar dependências
+            const require = createRequire(import.meta.url);
+            const forge = require('node-forge');
+            const fs = require('fs');
+            // Verificar se node-forge foi carregado corretamente
+            if (!(forge && forge.asn1 && forge.pkcs12)) {
+                throw new Error('node-forge não carregado corretamente');
+            }
+            // Ler arquivo P12
+            const p12Data = fs.readFileSync(p12Path);
+            // ✅ ESTRATÉGIA DE FALLBACK: Tentar várias abordagens para senhas
+            const passwordAttempts = [
+                password || '', // Senha fornecida ou string vazia
+                '', // Sem senha (string vazia)
+                undefined, // Sem senha (undefined)
+                null, // Sem senha (null)
+            ].filter((p, index, arr) => arr.indexOf(p) === index); // Remove duplicatas
+            // biome-ignore lint/suspicious/noExplicitAny: node-forge pkcs12FromAsn1 return type is complex
+            let p12 = null;
+            let usedPassword;
+            // Tentar cada abordagem de senha
+            for (const attemptPassword of passwordAttempts) {
+                try {
+                    let passwordDesc4 = '(fornecida)';
+                    if (attemptPassword === '') {
+                        passwordDesc4 = '(vazia)';
+                    }
+                    else if (attemptPassword === undefined) {
+                        passwordDesc4 = '(undefined)';
+                    }
+                    else if (attemptPassword === null) {
+                        passwordDesc4 = '(null)';
+                    }
+                    console.log('Tentando extrair P12 com senha:', passwordDesc4);
+                    const p12Asn1 = forge.asn1.fromDer(p12Data.toString('binary'));
+                    p12 = forge.pkcs12.pkcs12FromAsn1(p12Asn1, attemptPassword);
+                    usedPassword = attemptPassword;
+                    let passwordDesc5 = '(fornecida)';
+                    if (attemptPassword === '') {
+                        passwordDesc5 = '(vazia)';
+                    }
+                    else if (attemptPassword === undefined) {
+                        passwordDesc5 = '(undefined)';
+                    }
+                    else if (attemptPassword === null) {
+                        passwordDesc5 = '(null)';
+                    }
+                    console.log('P12 extraido com sucesso usando senha:', passwordDesc5);
+                    break;
+                }
+                catch (passwordError) {
+                    const errorMsg = passwordError instanceof Error
+                        ? passwordError.message
+                        : String(passwordError);
+                    let passwordDesc6 = '(fornecida)';
+                    if (attemptPassword === '') {
+                        passwordDesc6 = '(vazia)';
+                    }
+                    else if (attemptPassword === undefined) {
+                        passwordDesc6 = '(undefined)';
+                    }
+                    else if (attemptPassword === null) {
+                        passwordDesc6 = '(null)';
+                    }
+                    console.log('Falha com senha ' + passwordDesc6 + ':', errorMsg);
+                }
+            }
+            if (!p12) {
+                throw new Error('Não foi possível extrair o P12 com nenhuma abordagem de senha testada');
+            }
+            // Extrair certificado
+            const certBags = p12.getBags({ bagType: forge.pki.oids.certBag });
+            const certBagArray = certBags?.[forge.pki.oids.certBag];
+            if (!certBagArray || certBagArray.length === 0) {
+                throw new Error('Nenhum certificado encontrado no arquivo P12');
+            }
+            const cert = certBagArray[0]?.cert;
+            if (!cert) {
+                throw new Error('Certificado inválido no arquivo P12');
+            }
+            // Extrair chave privada
+            const keyBags = p12.getBags({
+                bagType: forge.pki.oids.pkcs8ShroudedKeyBag,
+            });
+            let privateKey = null;
+            const shroudedKeyBagArray = keyBags?.[forge.pki.oids.pkcs8ShroudedKeyBag];
+            if (shroudedKeyBagArray && shroudedKeyBagArray.length > 0) {
+                privateKey = shroudedKeyBagArray[0]?.key;
+            }
+            else {
+                // Tentar keyBag não shrouded
+                const unshroudedKeyBags = p12.getBags({
+                    bagType: forge.pki.oids.keyBag,
+                });
+                const unshroudedKeyBagArray = unshroudedKeyBags?.[forge.pki.oids.keyBag];
+                if (unshroudedKeyBagArray && unshroudedKeyBagArray.length > 0) {
+                    privateKey = unshroudedKeyBagArray[0]?.key;
+                }
+            }
+            if (!privateKey) {
+                throw new Error('Chave privada não encontrada no arquivo P12');
+            }
+            // Converter para PEM
+            const certPem = forge.pki.certificateToPem(cert);
+            const keyPem = forge.pki.privateKeyToPem(privateKey);
+            console.log('Certificado P12 extraido com sucesso');
+            console.log(`📋 Certificado válido de: ${cert.subject.getField('CN')?.value || 'N/A'}`);
+            console.log(`📅 Válido até: ${cert.validity.notAfter}`);
+            return { cert: certPem, key: keyPem };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`❌ Erro ao extrair certificado P12: ${errorMessage}`);
+            throw new Error(`Falha na extração P12: ${errorMessage}`);
+        }
+    }
+    /**
+     * ✅ NOVO: Configura certificado P12 extraído com Playwright
+     * @param origin Origem do certificado (protocolo + host)
+     * @param certPath Caminho para arquivo P12
+     * @param password Senha do arquivo P12
+     * @returns Contexto configurado com certificado extraído
+     */
+    static async configureExtractedP12Certificate(origin, certPath, password) {
+        try {
+            // Extrair certificado e chave do P12
+            const { cert, key } = await ApiActions.extractP12Certificate(certPath, password);
+            // ✅ CORRIGIDO: Usar createRequire para fs e path
+            const require = createRequire(import.meta.url);
+            const fs = require('fs');
+            const path = require('path');
+            // Criar arquivos temporários para cert e key
+            const tempDir = path.join(process.cwd(), '.temp-certs');
+            if (!fs.existsSync(tempDir)) {
+                fs.mkdirSync(tempDir, { recursive: true });
+            }
+            const tempCertPath = path.join(tempDir, 'cert-' + Date.now() + '.pem');
+            const tempKeyPath = path.join(tempDir, 'key-' + Date.now() + '.pem');
+            fs.writeFileSync(tempCertPath, cert);
+            fs.writeFileSync(tempKeyPath, key);
+            console.log('Certificado temporário criado:', tempCertPath);
+            console.log('Chave temporária criada:', tempKeyPath);
+            // Configurar contexto Playwright com certificado extraído
+            const context = await playwrightRequest.newContext({
+                ignoreHTTPSErrors: true, // ✅ SEMPRE IGNORAR SSL EM QA
+                clientCertificates: [
+                    {
+                        origin,
+                        certPath: tempCertPath,
+                        keyPath: tempKeyPath,
+                    },
+                ],
+                // ✅ NOVO: Proxy corporativo para certificados
+                proxy: {
+                    server: process.env.PROXY_URL || 'http://proxy.redecorp.br:8080',
+                },
+                timeout: TestContext.getProjectTimeout(),
+                extraHTTPHeaders: {
+                    'User-Agent': 'AutoCore-P12-Client/1.0',
+                    Accept: 'application/json, text/plain, */*',
+                    'Cache-Control': 'no-cache',
+                },
+            });
+            // Limpar arquivos temporários após uso (cleanup assíncrono)
+            setTimeout(() => {
+                try {
+                    if (fs.existsSync(tempCertPath))
+                        fs.unlinkSync(tempCertPath);
+                    if (fs.existsSync(tempKeyPath))
+                        fs.unlinkSync(tempKeyPath);
+                    console.log('Arquivos temporários de certificado removidos');
+                }
+                catch (cleanupError) {
+                    console.warn('Falha ao limpar arquivos temporários:', cleanupError);
+                }
+            }, 30_000); // Limpar após 30 segundos
+            console.log('Contexto P12 configurado com sucesso');
+            return context;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error('Erro ao configurar P12:', errorMessage);
+            throw new Error('Falha na configuracao P12: ' + errorMessage);
+        }
+    }
+    /**
+     * ✅ MELHORADO: Tentar configuração de certificado com estratégia P12 + fallback
+     */
+    static async tryClientCertificateConfig(origin, certPath, password) {
+        const baseConfig = {
+            ignoreHTTPSErrors: true,
+            timeout: TestContext.getProjectTimeout(),
+            extraHTTPHeaders: {
+                'User-Agent': 'AutoCore-Certificate-Client/1.0',
+                Accept: 'application/json, text/plain, */*',
+                'Cache-Control': 'no-cache',
+            },
+            storageState: undefined,
+            httpCredentials: undefined,
+            // ✅ NOVO: Proxy corporativo automático para certificados
+            proxy: {
+                server: process.env.PROXY_URL || 'http://proxy.redecorp.br:8080',
+            },
+        };
+        // ESTRATEGIA 1: Tentar extração P12 com node-forge (NOVO)
+        try {
+            console.log('Tentativa 1: Extração P12 com node-forge');
+            const context = await ApiActions.configureExtractedP12Certificate(origin, certPath, password);
+            console.log('Certificado P12 extraído e configurado com sucesso');
+            return context;
+        }
+        catch (p12Error) {
+            const p12ErrorMessage = p12Error instanceof Error ? p12Error.message : String(p12Error);
+            console.log('Falha na extração P12:', p12ErrorMessage);
+            // ESTRATEGIA 2: Tentar abordagem original SEM senha (compatível com projetos Java)
+            try {
+                console.log('Tentativa 2: Abordagem original SEM senha');
+                const contextWithoutPassword = await playwrightRequest.newContext({
+                    ...baseConfig,
+                    clientCertificates: [
+                        {
+                            origin,
+                            pfxPath: certPath,
+                            // passphrase omitida intencionalmente
+                        },
+                    ],
+                });
+                console.log('Certificado configurado com sucesso SEM senha (abordagem original)');
+                return contextWithoutPassword;
+            }
+            catch (errorWithoutPassword) {
+                const errorMessage = errorWithoutPassword instanceof Error
+                    ? errorWithoutPassword.message
+                    : String(errorWithoutPassword);
+                console.log('Falha sem senha (original):', errorMessage);
+                // ESTRATEGIA 3: Se falhar sem senha E temos senha, tentar COM senha
+                if (password && password.trim() !== '') {
+                    try {
+                        console.log('Tentativa 3: Abordagem original COM senha');
+                        const contextWithPassword = await playwrightRequest.newContext({
+                            ...baseConfig,
+                            clientCertificates: [
+                                {
+                                    origin,
+                                    pfxPath: certPath,
+                                    passphrase: password,
+                                },
+                            ],
+                        });
+                        console.log('Certificado configurado com sucesso COM senha (abordagem original)');
+                        return contextWithPassword;
+                    }
+                    catch (errorWithPassword) {
+                        const errorWithPasswordMessage = errorWithPassword instanceof Error
+                            ? errorWithPassword.message
+                            : String(errorWithPassword);
+                        console.error('Falha com senha (original):', errorWithPasswordMessage);
+                        // ESTRATEGIA 4: FALLBACK - Contexto sem certificado
+                        try {
+                            console.log('Tentativa 4: FALLBACK sem certificado');
+                            const fallbackContext = await playwrightRequest.newContext({
+                                ...baseConfig,
+                                ignoreHTTPSErrors: true,
+                                // Remover certificado e usar apenas ignoreHTTPSErrors
+                            });
+                            console.log('FALLBACK: Contexto criado SEM certificado (apenas ignoreHTTPSErrors)');
+                            console.log('SUGESTAO: Verifique se o certificado P12 está correto ou se o servidor aceita conexões sem certificado');
+                            return fallbackContext;
+                        }
+                        catch (fallbackError) {
+                            const fallbackMessage = fallbackError instanceof Error
+                                ? fallbackError.message
+                                : String(fallbackError);
+                            throw new Error('Certificado falhou em todas as tentativas:\\n1. Extração P12: ' +
+                                p12ErrorMessage +
+                                '\\n2. Original sem senha: ' +
+                                errorMessage +
+                                '\\n3. Original com senha: ' +
+                                errorWithPasswordMessage +
+                                '\\n4. Fallback: ' +
+                                fallbackMessage);
+                        }
+                    }
+                }
+                else {
+                    // ESTRATEGIA 4: Se não tem senha, tentar FALLBACK
+                    try {
+                        console.log('Tentativa 3 (sem senha): FALLBACK sem certificado');
+                        const fallbackContext = await playwrightRequest.newContext({
+                            ...baseConfig,
+                            ignoreHTTPSErrors: true,
+                            // Remover certificado e usar apenas ignoreHTTPSErrors
+                        });
+                        console.log('FALLBACK: Contexto criado SEM certificado (apenas ignoreHTTPSErrors)');
+                        console.log('SUGESTAO: Verifique se o certificado P12 está correto ou configure uma senha');
+                        return fallbackContext;
+                    }
+                    catch (fallbackError) {
+                        const fallbackMessage = fallbackError instanceof Error
+                            ? fallbackError.message
+                            : String(fallbackError);
+                        throw new Error('Certificado falhou em todas as tentativas:\\n1. Extração P12: ' +
+                            p12ErrorMessage +
+                            '\\n2. Original sem senha: ' +
+                            errorMessage +
+                            '\\n3. Fallback: ' +
+                            fallbackMessage);
+                    }
+                }
+            }
+        }
+    }
+    static getMetrics() {
+        return {
+            totalRequisicoes: ApiActions.requestCount,
+            totalSuccesso: ApiActions.successCount,
+            totalFalhas: ApiActions.failureCount,
+            foiUtilizado: ApiActions.foiUsado,
+            logsPerTest: ApiActions.logsPerTest,
+            duracoes: ApiActions.duracoes,
+            dadosGerais: ApiActions.dadosGerais,
+            inicioExecucao: ApiActions.inicioExecucao,
+            fimExecucao: ApiActions.fimExecucao,
+        };
+    }
+    static hasLogsForTest(testName) {
+        return !!(ApiActions.logsPerTest[testName] &&
+            ApiActions.logsPerTest[testName].length > 0);
+    }
+    static getLogsForTest(testName) {
+        return ApiActions.logsPerTest[testName] || [];
+    }
+    static async coletarDadosDoTeste() {
+        try {
+            await UnifiedReportManager.coletarDadosDoTeste();
+        }
+        catch (error) {
+            Logger.error('Erro ao coletar dados do teste via UnifiedReportManager', error);
+        }
+    }
+    /**
+     * ✅ Anexar resumo de logs
+     */
+    static async anexarResumoDeLogs() {
+        try {
+            const testInfo = TestContext.getSafeTestInfo();
+            if (!testInfo)
+                return;
+            const logResumo = Object.entries(ApiActions.logsPerTest)
+                .map(([teste, logs]) => '### ' + teste + '\\n' + logs.map((l) => '- ' + l).join('\\n'))
+                .join('\\n\\n');
+            await testInfo.attach('Resumo de Logs dos Testes', {
+                body: Buffer.from(logResumo, 'utf-8'),
+                contentType: 'text/markdown',
+            });
+        }
+        catch (error) {
+            Logger.error('Erro ao anexar resumo de logs:', error);
+        }
+    }
+    /**
+     * ✅ Anexar relatório final
+     */
+    static async anexarRelatorioFinal() {
+        try {
+            const testInfo = TestContext.getSafeTestInfo();
+            if (!testInfo)
+                return;
+            Logger.bloco('Finalizado contexto de requisição API');
+            const resultados = Object.entries(ApiActions.logsPerTest).map(([nome, logs]) => {
+                const temFalha = logs.some((l) => l.includes('X'));
+                return { nome, resultado: temFalha ? 'FAIL' : 'PASS' };
+            });
+            // Tentar usar UnifiedReportManager se disponível
+            try {
+                await UnifiedReportManager.finalizarTeste();
+                return; // Sucesso, sair da função
+            }
+            catch {
+                // Continuar para fallback
+            }
+            // Fallback para relatório simples em texto
+            const relatorioTexto = '# Relatório de Execução API\n\n' +
+                '## Resumo\n' +
+                '- Total de Testes: ' +
+                resultados.length +
+                '\n' +
+                '- Sucessos: ' +
+                resultados.filter((r) => r.resultado === 'PASS').length +
+                '\n' +
+                '- Falhas: ' +
+                resultados.filter((r) => r.resultado === 'FAIL').length +
+                '\n\n' +
+                '## Detalhes\n' +
+                resultados.map((r) => '- ' + r.nome + ': ' + r.resultado).join('\n');
+            await testInfo.attach('Relatório de Execução API', {
+                body: Buffer.from(relatorioTexto, 'utf-8'),
+                contentType: 'text/markdown',
+            });
+        }
+        catch (error) {
+            Logger.error('Erro ao anexar relatórios finais', error);
+        }
+    }
+    /**
+     * Verifica se o header deve ser mascarado nos logs.
+     * @param key Nome do header.
+     * @returns true se deve mascarar, false caso contrário.
+     */
+    static shouldMaskHeader(key) {
+        const sensitiveHeaders = [
+            'authorization',
+            'x-api-key',
+            'set-cookie',
+            'cookie',
+            'proxy-authorization',
+        ];
+        return sensitiveHeaders.includes(key.toLowerCase());
+    }
+    /**
+     * Aguarda um tempo fixo em segundos.
+     * Útil para aguardar processamento assíncrono, propagação de dados,
+     * ou cooldown entre chamadas de API.
+     *
+     * @param segundos - Tempo de espera em segundos
+     * @param descricao - Descrição do motivo da espera (para logs)
+     */
+    static async fixedWait(segundos, descricao = '') {
+        const ms = segundos * 1000;
+        const actionDesc = descricao || `Aguardando ${segundos}s`;
+        Logger.info(`[ApiActions] ⏱️ ${actionDesc}`);
+        let statementTimestamp = null;
+        try {
+            statementTimestamp = StatementTracker.startStatement('ApiActions', `fixedWait: ${actionDesc}`);
+        }
+        catch { }
+        const startTime = Date.now();
+        await new Promise((resolve) => setTimeout(resolve, ms));
+        const duration = Date.now() - startTime;
+        Logger.success(`[ApiActions] ✅ Espera concluída: ${actionDesc} (real: ${duration}ms)`);
+        try {
+            StatementTracker.recordAction('API', actionDesc, true, duration, { action: 'fixedWait' });
+        }
+        catch { }
+    }
+}
+// 🚫 AUTO-ATIVAÇÃO REMOVIDA: ApiActions são métodos internos que não devem ser interceptados
+// ApiActions.post(), .get(), etc. não são CTs válidos e devem ser filtrados
+// A interceptação foi removida para evitar falsos CTs nos relatórios
+// CÓDIGO REMOVIDO:
+// try {
+//   installDatabaseInterceptor(ApiActions, 'ApiActions')
+// } catch (error) {
+//   if (process.env.AUTOCORE_DEBUG_LOGS === 'true') {
+//     process.stderr.write(`[DatabaseInterceptor] Falha na auto-ativação ApiActions: ${String(error)}\n`)
+//   }
+// }