@silasfmartins/testhub 1.0.0

package/dist/src/utils/ConfigLogger.js

@@ -0,0 +1,611 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+/**
+ * Gerenciador de logs de configuração para Playwright
+ * Fornece informações detalhadas sobre configurações e ambiente
+ * ATUALIZADO: Integrado com a nova arquitetura unificada
+ */
+export class ConfigLogger {
+    static logFile = null;
+    static projectName = 'Projeto desconhecido';
+    static logToFile = false;
+    static initialized = false;
+    static startTime = new Date();
+    /**
+     * Inicializa o logger de configurações
+     * @param options Opções de inicialização
+     */
+    static init(options = {}) {
+        if (ConfigLogger.initialized || ConfigLogger.hasRunBefore())
+            return;
+        ConfigLogger.startTime = new Date();
+        ConfigLogger.projectName =
+            options.projectName || ConfigLogger.getProjectNameFromPackageJson();
+        ConfigLogger.logToFile = options.logToFile ?? false;
+        if (ConfigLogger.logToFile) {
+            const logDir = options.logDir || path.join(process.cwd(), 'logs');
+            if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+            }
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            ConfigLogger.logFile = path.join(logDir, `config-${timestamp}.log`);
+        }
+        ConfigLogger.initialized = true;
+        ConfigLogger.markAsRun();
+    }
+    /**
+     * Obtém o nome do projeto do package.json
+     */
+    static getProjectNameFromPackageJson() {
+        try {
+            const packagePath = path.join(process.cwd(), 'package.json');
+            if (fs.existsSync(packagePath)) {
+                const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+                return packageJson.name || 'Projeto desconhecido';
+            }
+        }
+        catch (error) {
+            ConfigLogger.warning('Não foi possível ler o package.json');
+        }
+        return 'Projeto desconhecido';
+    }
+    /**
+     * Escreve no arquivo de log
+     */
+    static appendToLogFile(message) {
+        if (!ConfigLogger.logFile)
+            return;
+        try {
+            const timestamp = new Date().toISOString();
+            fs.appendFileSync(ConfigLogger.logFile, `[${timestamp}] ${message}\n`);
+        }
+        catch (error) {
+            console.error('Erro ao escrever no arquivo de log:', error);
+        }
+    }
+    /**
+     * Registra log informativo
+     */
+    static info(message) {
+        console.log(`ℹ️  ${message}`);
+        if (ConfigLogger.logToFile) {
+            ConfigLogger.appendToLogFile(`INFO: ${message}`);
+        }
+    }
+    /**
+     * Registra log de sucesso
+     */
+    static success(message) {
+        console.log(`✅ ${message}`);
+        if (ConfigLogger.logToFile) {
+            ConfigLogger.appendToLogFile(`SUCCESS: ${message}`);
+        }
+    }
+    /**
+     * Registra log de aviso
+     */
+    static warning(message) {
+        console.warn(`⚠️  ${message}`);
+        if (ConfigLogger.logToFile) {
+            ConfigLogger.appendToLogFile(`WARNING: ${message}`);
+        }
+    }
+    /**
+     * Registra log de erro
+     */
+    static error(message, error) {
+        console.error(`❌ ${message}`);
+        if (error) {
+            console.error(error);
+        }
+        if (ConfigLogger.logToFile) {
+            ConfigLogger.appendToLogFile(`ERROR: ${message} ${error ? `\n${error.stack || error}` : ''}`);
+        }
+    }
+    /**
+     * Registra log crítico (erro grave que pode impedir a execução)
+     */
+    static critical(message, error) {
+        console.error(`🔥 CRÍTICO: ${message}`);
+        if (error) {
+            console.error(error);
+        }
+        if (ConfigLogger.logToFile) {
+            ConfigLogger.appendToLogFile(`CRITICAL: ${message} ${error ? `\n${error.stack || error}` : ''}`);
+        }
+    }
+    /**
+     * Registra resumo da configuração do ambiente
+     */
+    static logEnvironmentConfig() {
+        ConfigLogger.info('=== Configuração do Ambiente ===');
+        // Informações do sistema e runtime
+        ConfigLogger.info(`Node.js: ${process.version}`);
+        ConfigLogger.info(`Sistema operacional: ${process.platform} ${os.release()} (${process.arch})`);
+        ConfigLogger.info(`Memória total: ${Math.round(os.totalmem() / (1024 * 1024 * 1024))}GB`);
+        ConfigLogger.info(`Memória disponível: ${Math.round(os.freemem() / (1024 * 1024 * 1024))}GB`);
+        ConfigLogger.info(`CPUs: ${os.cpus().length} núcleos`);
+        ConfigLogger.info(`Usuário: ${os.userInfo().username}`);
+        ConfigLogger.info(`Nome da máquina: ${os.hostname()}`);
+        // Verificar variáveis de ambiente do CI
+        const isCi = process.env.CI === 'true' || process.env.TF_BUILD === 'true';
+        if (isCi) {
+            ConfigLogger.info('Executando em ambiente de CI/CD');
+            if (process.env.GITHUB_ACTIONS) {
+                ConfigLogger.info('CI: GitHub Actions');
+            }
+            else if (process.env.TF_BUILD) {
+                ConfigLogger.info('CI: Azure DevOps');
+            }
+        }
+    }
+    /**
+     * Registra variáveis de ambiente relevantes para o projeto
+     */
+    static logEnvironmentVariables() {
+        ConfigLogger.info('Variáveis de ambiente relevantes:');
+        const relevantVars = [
+            'NODE_ENV',
+            'ENV',
+            'CI',
+            'DEBUG',
+            'PROJECT_TYPE',
+            'BASE_URL',
+            'API_URL',
+            'TEST_ENV',
+            'USE_MOBILE',
+        ];
+        const apiVars = Object.keys(process.env)
+            .filter((key) => key.startsWith('BASE_URL_'))
+            .sort();
+        relevantVars.push(...apiVars);
+        // Log das variáveis encontradas
+        const foundVars = relevantVars.filter((varName) => process.env[varName]);
+        foundVars.forEach((varName) => {
+            const value = process.env[varName];
+            // Mascarar possíveis tokens/senhas
+            const maskedValue = varName.toLowerCase().includes('token') ||
+                varName.toLowerCase().includes('password') ||
+                varName.toLowerCase().includes('secret')
+                ? '***masked***'
+                : value;
+            ConfigLogger.info(` ${varName}: ${maskedValue}`);
+        });
+        // Se encontrou variáveis de API, fazer seção separada
+        const apiBaseVars = apiVars.filter((varName) => process.env[varName]);
+        if (apiBaseVars.length > 0) {
+            ConfigLogger.info('API configurada:');
+            apiBaseVars.forEach((varName) => {
+                ConfigLogger.info(` ${varName}: ${process.env[varName]}`);
+            });
+        }
+        // NOVO: Log de variáveis por tipo de projeto
+        const projectType = process.env.PROJECT_TYPE;
+        if (projectType) {
+            ConfigLogger.info(`Variáveis específicas para projeto ${projectType}:`);
+            switch (projectType) {
+                case 'Mobile':
+                    ConfigLogger.logMobileVariables();
+                    break;
+                case 'SSH':
+                    ConfigLogger.logSSHVariables();
+                    break;
+                case 'Banco':
+                    ConfigLogger.logDatabaseVariables();
+                    break;
+            }
+        }
+    }
+    /**
+     * NOVO: Log específico para variáveis Mobile
+     */
+    static logMobileVariables() {
+        const mobileVars = [
+            'USE_MOBILE',
+            'DEVICE_NAME',
+            'PLATFORM_NAME',
+            'PLATFORM_VERSION',
+            'APP_PACKAGE',
+        ];
+        mobileVars.forEach((varName) => {
+            if (process.env[varName]) {
+                ConfigLogger.info(` ${varName}: ${process.env[varName]}`);
+            }
+        });
+    }
+    /**
+     * NOVO: Log específico para variáveis SSH
+     */
+    static logSSHVariables() {
+        const sshVars = ['SSH_HOST', 'SSH_PORT', 'SSH_USER'];
+        sshVars.forEach((varName) => {
+            if (process.env[varName]) {
+                const value = varName.includes('PASS') || varName.includes('KEY')
+                    ? '***masked***'
+                    : process.env[varName];
+                ConfigLogger.info(` ${varName}: ${value}`);
+            }
+        });
+    }
+    /**
+     * NOVO: Log específico para variáveis de Banco
+     */
+    static logDatabaseVariables() {
+        const dbVars = ['DB_HOST', 'DB_PORT', 'DB_SERVICE', 'DB_USER'];
+        dbVars.forEach((varName) => {
+            if (process.env[varName]) {
+                const value = varName.includes('PASS')
+                    ? '***masked***'
+                    : process.env[varName];
+                ConfigLogger.info(` ${varName}: ${value}`);
+            }
+        });
+    }
+    /**
+     * Retorna o caminho do arquivo de lock usado para evitar inicialização múltipla
+     */
+    static getLockFilePath() {
+        return path.join(process.cwd(), '.configlogger.lock');
+    }
+    /**
+     * Verifica se o ConfigLogger já foi executado antes (evita inicialização múltipla)
+     */
+    static hasRunBefore() {
+        return fs.existsSync(ConfigLogger.getLockFilePath());
+    }
+    /**
+     * Marca o ConfigLogger como já inicializado
+     */
+    static markAsRun() {
+        try {
+            fs.writeFileSync(ConfigLogger.getLockFilePath(), ConfigLogger.startTime.toISOString());
+        }
+        catch (error) {
+            ConfigLogger.warning('Não foi possível criar arquivo de lock');
+        }
+    }
+    /**
+     * Limpa o estado e arquivos temporários do ConfigLogger
+     */
+    static cleanup() {
+        try {
+            const lockFile = ConfigLogger.getLockFilePath();
+            if (fs.existsSync(lockFile)) {
+                fs.unlinkSync(lockFile);
+            }
+        }
+        catch (error) {
+            ConfigLogger.warning('Erro ao limpar arquivos temporários do ConfigLogger');
+        }
+        ConfigLogger.initialized = false;
+        ConfigLogger.logFile = null;
+    }
+    /**
+     * Registra informações sobre o Playwright (versão otimizada)
+     */
+    static logPlaywrightConfig() {
+        if (!ConfigLogger.initialized) {
+            ConfigLogger.warning('ConfigLogger não foi inicializado antes de chamar logPlaywrightConfig');
+            return;
+        }
+        ConfigLogger.info('=== Configuração do Playwright ===');
+        try {
+            const configInfo = ConfigLogger.readPlaywrightConfigFile();
+            if (configInfo.found) {
+                ConfigLogger.success(`Configuração encontrada: ${configInfo.filename}`);
+                // Mostrar informações extraídas do arquivo
+                if (configInfo.testDir) {
+                    ConfigLogger.info(`Diretório de testes: ${configInfo.testDir}`);
+                }
+                if (configInfo.testMatch && configInfo.testMatch.length > 0) {
+                    ConfigLogger.info(`Padrões de teste: ${configInfo.testMatch.join(', ')}`);
+                }
+                if (configInfo.timeout) {
+                    ConfigLogger.info(`Timeout global: ${configInfo.timeout}ms`);
+                }
+                if (configInfo.expectTimeout) {
+                    ConfigLogger.info(`Timeout de expectativas: ${configInfo.expectTimeout}ms`);
+                }
+                if (configInfo.workers !== undefined) {
+                    ConfigLogger.info(`Workers: ${configInfo.workers === undefined ? 'automático' : configInfo.workers}`);
+                }
+                if (configInfo.retries !== undefined) {
+                    ConfigLogger.info(`Retries: ${configInfo.retries}`);
+                }
+                if (configInfo.reporters && configInfo.reporters.length > 0) {
+                    ConfigLogger.info(`Reporters: ${configInfo.reporters.join(', ')}`);
+                }
+                if (configInfo.projects !== undefined) {
+                    ConfigLogger.info(`Projetos configurados: ${configInfo.projects}`);
+                }
+                if (configInfo.globalSetup) {
+                    ConfigLogger.info(`Global Setup: ${configInfo.globalSetup}`);
+                }
+                if (configInfo.globalTeardown) {
+                    ConfigLogger.info(`Global Teardown: ${configInfo.globalTeardown}`);
+                }
+                if (configInfo.baseURL) {
+                    ConfigLogger.info(`URL Base: ${configInfo.baseURL}`);
+                }
+                if (configInfo.trace) {
+                    ConfigLogger.info(`Trace: ${configInfo.trace}`);
+                }
+                if (configInfo.fullyParallel !== undefined) {
+                    ConfigLogger.info(`Execução paralela: ${configInfo.fullyParallel ? 'habilitada' : 'desabilitada'}`);
+                }
+            }
+            else {
+                ConfigLogger.warning('Nenhum arquivo de configuração do Playwright encontrado');
+                ConfigLogger.info('Usando configurações padrão do Playwright');
+            }
+        }
+        catch (error) {
+            ConfigLogger.error('Erro ao ler configuração do Playwright', error);
+        }
+    }
+    /**
+     * Lê e extrai informações do arquivo de configuração do Playwright
+     * sem executar comandos externos (apenas parsing de texto)
+     */
+    static readPlaywrightConfigFile() {
+        const configFiles = [
+            'playwright.config.ts',
+            'playwright.config.js',
+            '.playwright.config.ts',
+            '.playwright.config.js',
+        ];
+        for (const filename of configFiles) {
+            const configPath = path.resolve(process.cwd(), filename);
+            if (fs.existsSync(configPath)) {
+                try {
+                    const content = fs.readFileSync(configPath, 'utf-8');
+                    const parsed = ConfigLogger.parseConfigContent(content);
+                    return {
+                        found: true,
+                        filename,
+                        ...parsed,
+                    };
+                }
+                catch (error) {
+                    ConfigLogger.warning(`Erro ao ler ${filename}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        return { found: false };
+    }
+    /**
+     * Extrai informações de configuração do conteúdo do arquivo usando regex
+     * (parsing simples sem executar código)
+     */
+    static parseConfigContent(content) {
+        const result = {};
+        // Remove comentários e quebras de linha para facilitar parsing
+        const cleanContent = content
+            .replace(/\/\*[\s\S]*?\*\//g, '') // Remove comentários /* */
+            .replace(/\/\/.*$/gm, '') // Remove comentários //
+            .replace(/\s+/g, ' ') // Normaliza espaços
+            .trim();
+        // Extrair testDir
+        const testDirMatch = cleanContent.match(/testDir:\s*['"`]([^'"`]+)['"`]/);
+        if (testDirMatch) {
+            result.testDir = testDirMatch[1];
+        }
+        // Extrair testMatch
+        const testMatchMatch = cleanContent.match(/testMatch:\s*\[(.*?)\]/);
+        if (testMatchMatch) {
+            const matches = testMatchMatch[1].match(/['"`]([^'"`]+)['"`]/g);
+            if (matches) {
+                result.testMatch = matches.map((m) => m.replace(/['"`]/g, ''));
+            }
+        }
+        // Extrair timeout
+        const timeoutMatch = cleanContent.match(/timeout:\s*(\d+)/);
+        if (timeoutMatch) {
+            result.timeout = Number.parseInt(timeoutMatch[1]);
+        }
+        // Extrair expect timeout
+        const expectTimeoutMatch = cleanContent.match(/expect:\s*{[^}]*timeout:\s*(\d+)/);
+        if (expectTimeoutMatch) {
+            result.expectTimeout = Number.parseInt(expectTimeoutMatch[1]);
+        }
+        // Extrair workers
+        const workersMatch = cleanContent.match(/workers:\s*(?:process\.env\.CI\s*\?\s*(\d+)\s*:\s*(\d+)|(\d+))/);
+        if (workersMatch) {
+            result.workers = Number.parseInt(workersMatch[3] || workersMatch[2] || workersMatch[1]);
+        }
+        // Extrair retries
+        const retriesMatch = cleanContent.match(/retries:\s*(?:process\.env\.CI\s*\?\s*(\d+)\s*:\s*(\d+)|(\d+))/);
+        if (retriesMatch) {
+            result.retries = Number.parseInt(retriesMatch[3] || retriesMatch[2] || retriesMatch[1]);
+        }
+        // Extrair reporters - ATUALIZADO: detecta CustomReporter
+        const reporterMatch = cleanContent.match(/reporter:\s*\[(.*?)\]/);
+        if (reporterMatch) {
+            const reporters = reporterMatch[1].match(/['"`]([^'"`]+)['"`]/g);
+            if (reporters) {
+                result.reporters = reporters.map((r) => r.replace(/['"`]/g, ''));
+            }
+            // NOVO: Detectar se está usando o CustomReporter
+            if (reporterMatch[1].includes('CustomReporter') ||
+                reporterMatch[1].includes('@silasfmartins/testhub/reporter')) {
+                result.reporters = result.reporters || [];
+                if (!result.reporters.includes('CustomReporter')) {
+                    result.reporters.push('CustomReporter (Unificado)');
+                }
+            }
+        }
+        // Contar projetos
+        const projectsMatch = cleanContent.match(/projects:\s*\[(.*?)\]/);
+        if (projectsMatch) {
+            const projectCount = (projectsMatch[1].match(/{/g) || []).length;
+            result.projects = projectCount;
+        }
+        // Extrair globalSetup
+        const globalSetupMatch = cleanContent.match(/globalSetup:\s*['"`]([^'"`]+)['"`]/);
+        if (globalSetupMatch) {
+            result.globalSetup = globalSetupMatch[1];
+        }
+        // Extrair globalTeardown
+        const globalTeardownMatch = cleanContent.match(/globalTeardown:\s*['"`]([^'"`]+)['"`]/);
+        if (globalTeardownMatch) {
+            result.globalTeardown = globalTeardownMatch[1];
+        }
+        // Extrair baseURL da seção use
+        const baseURLMatch = cleanContent.match(/use:\s*{[^}]*baseURL:\s*(?:process\.env\.[\w_]+\s*\|\|\s*)?['"`]([^'"`]+)['"`]/);
+        if (baseURLMatch) {
+            result.baseURL = baseURLMatch[1];
+        }
+        // Extrair trace
+        const traceMatch = cleanContent.match(/trace:\s*['"`]([^'"`]+)['"`]/);
+        if (traceMatch) {
+            result.trace = traceMatch[1];
+        }
+        // Extrair fullyParallel
+        const fullyParallelMatch = cleanContent.match(/fullyParallel:\s*(true|false)/);
+        if (fullyParallelMatch) {
+            result.fullyParallel = fullyParallelMatch[1] === 'true';
+        }
+        return result;
+    }
+    /**
+     * NOVO: Gera relatório de configuração do projeto
+     */
+    static generateProjectReport() {
+        const projectType = process.env.PROJECT_TYPE;
+        const environment = process.env.NODE_ENV || process.env.ENV;
+        const configuredFeatures = [];
+        const missingFeatures = [];
+        // Verificar recursos configurados
+        if (process.env.BASE_URL)
+            configuredFeatures.push('Frontend Base URL');
+        if (Object.keys(process.env).some((key) => key.startsWith('BASE_URL_')))
+            configuredFeatures.push('API URLs');
+        if (process.env.USE_MOBILE === 'true')
+            configuredFeatures.push('Mobile Testing');
+        if (process.env.SSH_HOST)
+            configuredFeatures.push('SSH Testing');
+        if (process.env.DB_HOST)
+            configuredFeatures.push('Database Testing');
+        // Verificar recursos em falta baseado no tipo de projeto
+        if (projectType === 'Frontend' && !process.env.BASE_URL)
+            missingFeatures.push('Frontend Base URL');
+        if (projectType === 'API' &&
+            !Object.keys(process.env).some((key) => key.startsWith('BASE_URL_')))
+            missingFeatures.push('API URLs');
+        if (projectType === 'Mobile' && process.env.USE_MOBILE !== 'true')
+            missingFeatures.push('Mobile Configuration');
+        if (projectType === 'SSH' && !process.env.SSH_HOST)
+            missingFeatures.push('SSH Configuration');
+        if (projectType === 'Banco' && !process.env.DB_HOST)
+            missingFeatures.push('Database Configuration');
+        return {
+            projectName: ConfigLogger.projectName,
+            projectType,
+            environment,
+            configuredFeatures,
+            missingFeatures,
+        };
+    }
+    /**
+     * NOVO: Log do relatório de projeto
+     */
+    static logProjectReport() {
+        const report = ConfigLogger.generateProjectReport();
+        ConfigLogger.info('=== Relatório do Projeto ===');
+        ConfigLogger.info(`Nome: ${report.projectName}`);
+        if (report.projectType)
+            ConfigLogger.info(`Tipo: ${report.projectType}`);
+        if (report.environment)
+            ConfigLogger.info(`Ambiente: ${report.environment}`);
+        if (report.configuredFeatures.length > 0) {
+            ConfigLogger.info(`Recursos configurados: ${report.configuredFeatures.join(', ')}`);
+        }
+        if (report.missingFeatures.length > 0) {
+            ConfigLogger.warning(`Recursos em falta: ${report.missingFeatures.join(', ')}`);
+        }
+        else {
+            ConfigLogger.success('Todos os recursos necessários estão configurados');
+        }
+    }
+    // ✨ NOVOS MÉTODOS PARA SEPARAÇÃO VISUAL DE MÉTODOS
+    /**
+     * 🚀 Inicia execução de um método com separador visual
+     */
+    static methodStart(methodName, className, params) {
+        const timestamp = new Date().toLocaleTimeString('pt-BR');
+        const fullMethodName = className ? `${className}.${methodName}` : methodName;
+        const paramStr = params && params.length > 0
+            ? params
+                .map((p) => typeof p === 'string' && p.length > 20
+                ? `${p.substring(0, 17)}...`
+                : String(p))
+                .join(', ')
+            : 'nenhum';
+        console.log();
+        console.log('┌─────────────────────────────────────────────────────────────────┐');
+        console.log(`│ 🚀 EXECUTANDO: ${fullMethodName.padEnd(42)} │`);
+        console.log(`│ ⏰ ${timestamp} | 📊 Parâmetros: ${paramStr.padEnd(28)} │`);
+        console.log('└─────────────────────────────────────────────────────────────────┘');
+        if (ConfigLogger.logToFile) {
+            ConfigLogger.appendToLogFile(`METHOD_START: ${fullMethodName} | Params: ${paramStr} | Time: ${timestamp}`);
+        }
+    }
+    /**
+     * ✅ Finaliza execução de um método
+     */
+    static methodEnd(methodName, className, success = true, duration) {
+        const fullMethodName = className ? `${className}.${methodName}` : methodName;
+        const status = success ? '✅ SUCESSO' : '❌ ERRO';
+        const durationStr = duration ? ` em ${duration}ms` : '';
+        console.log(`${status}: ${fullMethodName}${durationStr}`);
+        console.log('─'.repeat(65));
+        if (ConfigLogger.logToFile) {
+            ConfigLogger.appendToLogFile(`METHOD_END: ${fullMethodName} | Status: ${success ? 'SUCCESS' : 'ERROR'}${durationStr}`);
+        }
+    }
+    /**
+     * 📋 Log simples de método com separador pequeno
+     */
+    static methodLog(methodName, className) {
+        const fullMethodName = className ? `${className}.${methodName}` : methodName;
+        const timestamp = new Date().toLocaleTimeString('pt-BR');
+        console.log();
+        console.log(`🔧 [${timestamp}] Executando: ${fullMethodName}`);
+        console.log('─'.repeat(40));
+        if (ConfigLogger.logToFile) {
+            ConfigLogger.appendToLogFile(`METHOD_LOG: ${fullMethodName} | Time: ${timestamp}`);
+        }
+    }
+    /**
+     * 🎯 Log de separação entre grupos de métodos
+     */
+    static sectionSeparator(sectionName) {
+        console.log();
+        console.log('═'.repeat(65));
+        console.log(`🎯 ${sectionName.toUpperCase()}`);
+        console.log('═'.repeat(65));
+        if (ConfigLogger.logToFile) {
+            ConfigLogger.appendToLogFile(`SECTION: ${sectionName}`);
+        }
+    }
+    /**
+     * 📖 Wrapper para executar método com logs automáticos
+     */
+    static async executeWithLogs(methodName, className, method, params) {
+        const startTime = Date.now();
+        ConfigLogger.methodStart(methodName, className, params);
+        try {
+            const result = await method();
+            const duration = Date.now() - startTime;
+            ConfigLogger.methodEnd(methodName, className, true, duration);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            ConfigLogger.methodEnd(methodName, className, false, duration);
+            ConfigLogger.error(`Erro em ${className}.${methodName}`, error);
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { FullConfig, FullResult, Reporter, Suite, TestCase, TestResult } from '@playwright/test/reporter';
+export default class CustomReporter implements Reporter {
+    private testCount;
+    private completedTests;
+    private projectRoot;
+    private ctsByCN;
+    private statementTracker?;
+    onBegin(config: FullConfig, suite: Suite): void;
+    private countAllTests;
+    private mapCNsAndCTs;
+    private detectProjectType;
+    private getStatementTracker;
+    onTestBegin(test: TestCase): void;
+    onTestEnd(test: TestCase, result: TestResult): Promise<void>;
+    private mapToCoverageType;
+    onEnd(_result: FullResult): Promise<void>;
+    /**
+     * 📡 Copia os network logs de test-results/network-logs/ para playwright-report/evidence/network-logs/
+     * Isso acontece APÓS a geração do relatório HTML pelo Playwright
+     */
+    private copyNetworkLogsToReport;
+}