@silasfmartins/testhub 1.0.0

package/dist/src/utils/TerminalLogCapture.js

@@ -0,0 +1,531 @@
+/**
+ * 📋 Sistema de Captura Completa de Logs do Terminal
+ * @description Captura TODOS os logs (console.log, Logger, etc.) que aparecem no terminal
+ * @author AutoCore Team
+ * @version 1.1.0
+ * 🔧 ATUALIZAÇÃO: Logs são persistidos em arquivo para compartilhar entre workers do Playwright
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+// 🆕 Caminho do arquivo de logs compartilhado entre workers
+const SHARED_LOGS_PATH = resolve(process.cwd(), '.rbqa', 'captured-logs.json');
+/**
+ * 📊 Sistema de captura de logs do terminal
+ * 🔧 NOTA: Cada worker do Playwright tem sua própria instância em memória,
+ * mas os logs são persistidos em arquivo para compartilhamento.
+ */
+export class TerminalLogCapture {
+    static isActive = false;
+    static logs = [];
+    static logsByTest = new Map();
+    static currentTestName = null;
+    static currentCTName = null; // 🆕 Nome do CT atual
+    static workerId = TerminalLogCapture.generateWorkerId(); // 🆕 ID único do worker
+    static globalLogIndex = 0; // 🆕 Contador global de logs
+    static logListeners = new Map();
+    // Guardar funções originais do console
+    static originalConsole = {
+        log: console.log,
+        info: console.info,
+        warn: console.warn,
+        error: console.error,
+        debug: console.debug,
+    };
+    // Flag para evitar recursão infinita
+    static isCapturing = false;
+    /**
+     * 🆕 Gera um ID único para este worker
+     */
+    static generateWorkerId() {
+        // Tentar usar variáveis de ambiente padrão do Playwright
+        const workerIndex = process.env.TEST_WORKER_INDEX || process.env.PLAYWRIGHT_TEST_WORKER_INDEX;
+        if (workerIndex !== undefined) {
+            return `worker-${workerIndex}`;
+        }
+        // Fallback: gerar ID baseado em timestamp + random
+        return `worker-${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 7)}`;
+    }
+    /**
+     * 🚀 Inicia captura de logs
+     */
+    static start() {
+        if (TerminalLogCapture.isActive) {
+            return;
+        }
+        TerminalLogCapture.isActive = true;
+        TerminalLogCapture.logs = [];
+        TerminalLogCapture.logsByTest.clear();
+        // 🆕 Sincronizar índice global com arquivo existente
+        TerminalLogCapture.syncGlobalIndex();
+        globalThis.TerminalLogCapture = TerminalLogCapture;
+        // Interceptar console.log
+        console.log = (...args) => {
+            TerminalLogCapture.captureLog('log', args);
+            TerminalLogCapture.originalConsole.log.apply(console, args);
+        };
+        // Interceptar console.info
+        console.info = (...args) => {
+            TerminalLogCapture.captureLog('info', args);
+            TerminalLogCapture.originalConsole.info.apply(console, args);
+        };
+        // Interceptar console.warn
+        console.warn = (...args) => {
+            TerminalLogCapture.captureLog('warn', args);
+            TerminalLogCapture.originalConsole.warn.apply(console, args);
+        };
+        // Interceptar console.error
+        console.error = (...args) => {
+            TerminalLogCapture.captureLog('error', args);
+            TerminalLogCapture.originalConsole.error.apply(console, args);
+        };
+        // Interceptar console.debug
+        console.debug = (...args) => {
+            TerminalLogCapture.captureLog('debug', args);
+            TerminalLogCapture.originalConsole.debug.apply(console, args);
+        };
+    }
+    /**
+     * 🔄 Sincroniza índice global com arquivo existente
+     */
+    static syncGlobalIndex() {
+        try {
+            if (existsSync(SHARED_LOGS_PATH)) {
+                const data = JSON.parse(readFileSync(SHARED_LOGS_PATH, 'utf8'));
+                TerminalLogCapture.globalLogIndex = data.globalIndex || 0;
+            }
+        }
+        catch {
+            // Se erro, começar do zero
+            TerminalLogCapture.globalLogIndex = 0;
+        }
+    }
+    /**
+     * 📝 Captura um log
+     * 🔧 ATUALIZADO: Persiste logs em arquivo JSON compartilhado entre workers
+     */
+    static captureLog(level, args) {
+        // Evitar recursão infinita
+        if (TerminalLogCapture.isCapturing) {
+            return;
+        }
+        TerminalLogCapture.isCapturing = true;
+        try {
+            // Converter argumentos em string
+            const message = args
+                .map((arg) => {
+                if (typeof arg === 'string')
+                    return arg;
+                if (typeof arg === 'object') {
+                    try {
+                        return JSON.stringify(arg, null, 2);
+                    }
+                    catch {
+                        return String(arg);
+                    }
+                }
+                return String(arg);
+            })
+                .join(' ');
+            // Capturar stack trace para logs de erro
+            let stackTrace;
+            if (level === 'error') {
+                try {
+                    const stack = new Error().stack;
+                    if (stack) {
+                        stackTrace = stack.split('\n').slice(2).join('\n');
+                    }
+                }
+                catch {
+                    // Ignorar erro ao capturar stack
+                }
+            }
+            // 🆕 Incrementar índice global
+            TerminalLogCapture.globalLogIndex++;
+            const capturedLog = {
+                timestamp: new Date().toISOString(),
+                level,
+                message,
+                testName: TerminalLogCapture.currentTestName || undefined,
+                ctName: TerminalLogCapture.currentCTName || undefined, // 🆕 CT atual
+                workerId: TerminalLogCapture.workerId, // 🆕 ID do worker
+                stackTrace,
+                index: TerminalLogCapture.globalLogIndex, // 🆕 Índice global
+            };
+            // Adicionar ao array geral
+            TerminalLogCapture.logs.push(capturedLog);
+            // Adicionar ao array do teste atual (se houver)
+            if (TerminalLogCapture.currentTestName) {
+                if (!TerminalLogCapture.logsByTest.has(TerminalLogCapture.currentTestName)) {
+                    TerminalLogCapture.logsByTest.set(TerminalLogCapture.currentTestName, []);
+                }
+                TerminalLogCapture.logsByTest
+                    .get(TerminalLogCapture.currentTestName)
+                    .push(capturedLog);
+            }
+            // 🆕 SEMPRE persistir em arquivo JSON compartilhado (essencial para multi-worker)
+            TerminalLogCapture.persistLogToSharedFile(capturedLog);
+            // Notificar listeners em tempo real
+            TerminalLogCapture.notifyListeners(capturedLog);
+            // Salvar em arquivo em tempo real (opcional - log de texto)
+            if (process.env.SAVE_LOGS_REALTIME === 'true') {
+                TerminalLogCapture.appendToLogFile(capturedLog);
+            }
+        }
+        finally {
+            TerminalLogCapture.isCapturing = false;
+        }
+    }
+    /**
+     * 🆕 Persiste log no arquivo JSON compartilhado entre workers
+     */
+    static persistLogToSharedFile(log) {
+        try {
+            const dir = resolve(process.cwd(), '.rbqa');
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            // 🆕 Usar arquivo específico do worker para evitar race conditions
+            const workerId = TerminalLogCapture.getWorkerId();
+            const workerLogPath = resolve(dir, `captured-logs-${workerId}.json`);
+            // Ler logs existentes DESTE WORKER
+            let existingData = { globalIndex: 0, logs: [] };
+            if (existsSync(workerLogPath)) {
+                try {
+                    existingData = JSON.parse(readFileSync(workerLogPath, 'utf8'));
+                }
+                catch {
+                    // Se arquivo corrompido, criar novo
+                    existingData = { globalIndex: 0, logs: [] };
+                }
+            }
+            // Adicionar novo log
+            existingData.logs.push(log);
+            existingData.globalIndex = log.index || existingData.globalIndex + 1;
+            // Salvar arquivo (com retry para evitar conflitos entre workers)
+            TerminalLogCapture.writeWithRetry(workerLogPath, JSON.stringify(existingData, null, 2));
+        }
+        catch {
+            // Silenciosamente ignorar erros de persistência
+        }
+    }
+    /**
+     * 🆕 Escreve arquivo com retry para evitar conflitos
+     */
+    static writeWithRetry(filePath, content, maxRetries = 3) {
+        for (let i = 0; i < maxRetries; i++) {
+            try {
+                writeFileSync(filePath, content, 'utf8');
+                return;
+            }
+            catch {
+                if (i === maxRetries - 1)
+                    throw new Error('Failed to write after retries');
+                // Esperar um pouco antes de tentar novamente
+                const waitTime = Math.random() * 50 + 10;
+                const start = Date.now();
+                while (Date.now() - start < waitTime) { /* busy wait */ }
+            }
+        }
+    }
+    /**
+     * 🆕 Obtém todos os logs do arquivo compartilhado (para uso cross-worker)
+     */
+    static getSharedLogs() {
+        try {
+            const dir = resolve(process.cwd(), '.rbqa');
+            if (!existsSync(dir))
+                return [];
+            // 🆕 Ler de TODOS os arquivos de logs (worker-specific)
+            // Usar require('fs') dinâmico para garantir acesso ao readdirSync
+            const fs = require('fs');
+            const files = fs.readdirSync(dir).filter((f) => f.startsWith('captured-logs-') && f.endsWith('.json'));
+            let allLogs = [];
+            for (const file of files) {
+                try {
+                    const content = readFileSync(resolve(dir, file), 'utf8');
+                    const data = JSON.parse(content);
+                    if (Array.isArray(data.logs)) {
+                        allLogs = allLogs.concat(data.logs);
+                    }
+                }
+                catch {
+                    // Ignore
+                }
+            }
+            // Ordenar por timestamp pois índices são locais por worker
+            return allLogs.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        }
+        catch {
+            // Se erro, retornar vazio
+            return [];
+        }
+    }
+    /**
+     * 🆕 Obtém índice global atual do arquivo compartilhado
+     */
+    static getSharedGlobalIndex() {
+        try {
+            if (existsSync(SHARED_LOGS_PATH)) {
+                const data = JSON.parse(readFileSync(SHARED_LOGS_PATH, 'utf8'));
+                return data.globalIndex || 0;
+            }
+        }
+        catch {
+            // Se erro, retornar 0
+        }
+        return 0;
+    }
+    /**
+     * 🆕 Obtém o índice global atual em memória (sem acessar arquivo)
+     */
+    static getCurrentGlobalIndex() {
+        return TerminalLogCapture.globalLogIndex;
+    }
+    /**
+     * 🆕 Registra listener para receber logs em tempo real (usado pelos CTs)
+     */
+    static addListener(id, listener) {
+        TerminalLogCapture.logListeners.set(id, listener);
+    }
+    /**
+     * 🆕 Remove listener registrado
+     */
+    static removeListener(id) {
+        TerminalLogCapture.logListeners.delete(id);
+    }
+    static notifyListeners(log) {
+        if (TerminalLogCapture.logListeners.size === 0) {
+            return;
+        }
+        for (const listener of TerminalLogCapture.logListeners.values()) {
+            try {
+                listener(log);
+            }
+            catch {
+                // Ignorar erros de listeners para não quebrar captura principal
+            }
+        }
+    }
+    /**
+     * 🆕 Limpa arquivo de logs compartilhado (usar no início de nova execução)
+     */
+    static clearSharedLogs() {
+        try {
+            if (existsSync(SHARED_LOGS_PATH)) {
+                writeFileSync(SHARED_LOGS_PATH, JSON.stringify({ globalIndex: 0, logs: [] }, null, 2), 'utf8');
+            }
+            TerminalLogCapture.globalLogIndex = 0;
+        }
+        catch {
+            // Silenciosamente ignorar
+        }
+    }
+    /**
+     * 🔄 Define o teste atual
+     */
+    static setCurrentTest(testName) {
+        TerminalLogCapture.currentTestName = testName;
+        if (!TerminalLogCapture.logsByTest.has(testName)) {
+            TerminalLogCapture.logsByTest.set(testName, []);
+            // ✅ USAR CONSOLE NORMAL para aparecer nos logs
+        }
+        else {
+            const existingLogs = TerminalLogCapture.logsByTest.get(testName).length;
+        }
+    }
+    /**
+     * 🏁 Limpa o teste atual
+     */
+    static clearCurrentTest() {
+        TerminalLogCapture.currentTestName = null;
+    }
+    /**
+     * 🆕 Define o CT atual (para filtros mais precisos)
+     */
+    static setCurrentCT(ctName) {
+        TerminalLogCapture.currentCTName = ctName;
+    }
+    /**
+     * 🆕 Limpa o CT atual
+     */
+    static clearCurrentCT() {
+        TerminalLogCapture.currentCTName = null;
+    }
+    /**
+     * 🆕 Obtém o worker ID atual
+     */
+    static getWorkerId() {
+        return TerminalLogCapture.workerId;
+    }
+    /**
+     * 🆕 Obtém logs filtrados por CT name (funciona em single e multi-worker)
+     */
+    static getLogsForCT(ctName, testName) {
+        // 1. Primeiro tentar da memória local (single-worker ou mesmo worker)
+        let logs = TerminalLogCapture.logs.filter(log => {
+            const matchCT = log.ctName === ctName || log.message.includes(ctName);
+            const matchTest = !testName || log.testName === testName || log.message.includes(testName);
+            return matchCT && matchTest;
+        });
+        // 2. Se não encontrou, tentar do arquivo compartilhado (multi-worker)
+        if (logs.length === 0) {
+            const sharedLogs = TerminalLogCapture.getSharedLogs();
+            logs = sharedLogs.filter(log => {
+                const matchCT = log.ctName === ctName || log.message.includes(ctName);
+                const matchTest = !testName || log.testName === testName || log.message.includes(testName);
+                return matchCT && matchTest;
+            });
+        }
+        // 3. Ordenar por índice global
+        return logs.sort((a, b) => (a.index || 0) - (b.index || 0));
+    }
+    /**
+     * 🆕 Obtém todos os logs combinando memória e arquivo compartilhado (para multi-worker)
+     */
+    static getAllLogsCombined() {
+        // Combinar logs da memória com logs do arquivo compartilhado
+        const memoryLogs = TerminalLogCapture.logs;
+        const sharedLogs = TerminalLogCapture.getSharedLogs();
+        // Usar Map para deduplicar por índice
+        const logsMap = new Map();
+        for (const log of sharedLogs) {
+            if (log.index) {
+                logsMap.set(log.index, log);
+            }
+        }
+        // Logs da memória têm prioridade (mais recentes)
+        for (const log of memoryLogs) {
+            if (log.index) {
+                logsMap.set(log.index, log);
+            }
+        }
+        // Retornar ordenado por índice
+        return Array.from(logsMap.values()).sort((a, b) => (a.index || 0) - (b.index || 0));
+    }
+    /**
+     * 🆕 Obtém logs por range de índice (funciona em single e multi-worker)
+     */
+    static getLogsByIndexRange(startIndex, endIndex) {
+        // Combinar todas as fontes
+        const allLogs = TerminalLogCapture.getAllLogsCombined();
+        return allLogs.filter(log => {
+            const logIndex = log.index || 0;
+            if (endIndex !== undefined) {
+                return logIndex >= startIndex && logIndex <= endIndex;
+            }
+            return logIndex >= startIndex;
+        });
+    }
+    /**
+     * 📊 Retorna todos os logs capturados
+     */
+    static getAllLogs() {
+        return [...TerminalLogCapture.logs];
+    }
+    /**
+     * 📋 Retorna logs de um teste específico
+     */
+    static getLogsForTest(testName) {
+        return TerminalLogCapture.logsByTest.get(testName) || [];
+    }
+    /**
+     * 📊 Retorna todos os logs organizados por teste
+     */
+    static getLogsByTest() {
+        return new Map(TerminalLogCapture.logsByTest);
+    }
+    /**
+     * 💾 Salva logs em arquivo JSON
+     */
+    static saveToFile(outputPath = './test-results/terminal-logs.json') {
+        try {
+            const dir = outputPath.substring(0, outputPath.lastIndexOf('/'));
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            const data = {
+                captureStarted: TerminalLogCapture.logs[0]?.timestamp || new Date().toISOString(),
+                captureEnded: new Date().toISOString(),
+                totalLogs: TerminalLogCapture.logs.length,
+                logsByTest: Object.fromEntries(Array.from(TerminalLogCapture.logsByTest.entries()).map(([testName, logs]) => [
+                    testName,
+                    {
+                        count: logs.length,
+                        logs,
+                    },
+                ])),
+                allLogs: TerminalLogCapture.logs,
+            };
+            writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf8');
+            TerminalLogCapture.originalConsole.info(`✅ Logs salvos em: ${outputPath}`);
+        }
+        catch (error) {
+            TerminalLogCapture.originalConsole.error(`❌ Erro ao salvar logs: ${error}`);
+        }
+    }
+    /**
+     * 📝 Adiciona log em arquivo em tempo real
+     */
+    static appendToLogFile(log) {
+        try {
+            const logPath = './test-results/terminal-logs-realtime.log';
+            const dir = logPath.substring(0, logPath.lastIndexOf('/'));
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            const logLine = `[${log.timestamp}] [${log.level.toUpperCase()}]${log.testName ? ` [${log.testName}]` : ''} ${log.message}\n`;
+            appendFileSync(logPath, logLine, 'utf8');
+        }
+        catch (error) {
+            // Ignorar erro silenciosamente
+        }
+    }
+    /**
+     * 🛑 Para captura e restaura console original
+     */
+    static stop() {
+        if (!TerminalLogCapture.isActive) {
+            return;
+        }
+        console.log = TerminalLogCapture.originalConsole.log;
+        console.info = TerminalLogCapture.originalConsole.info;
+        console.warn = TerminalLogCapture.originalConsole.warn;
+        console.error = TerminalLogCapture.originalConsole.error;
+        console.debug = TerminalLogCapture.originalConsole.debug;
+        TerminalLogCapture.isActive = false;
+        // Salvar logs finais
+        TerminalLogCapture.saveToFile();
+    }
+    /**
+     * 🧹 Limpa todos os logs
+     */
+    static clear() {
+        TerminalLogCapture.logs = [];
+        TerminalLogCapture.logsByTest.clear();
+        TerminalLogCapture.currentTestName = null;
+    }
+    /**
+     * 📊 Estatísticas de logs
+     */
+    static getStats() {
+        const stats = {
+            totalLogs: TerminalLogCapture.logs.length,
+            byLevel: {
+                log: 0,
+                info: 0,
+                warn: 0,
+                error: 0,
+                debug: 0,
+            },
+            byTest: {},
+            testsWithLogs: TerminalLogCapture.logsByTest.size,
+        };
+        for (const log of TerminalLogCapture.logs) {
+            stats.byLevel[log.level]++;
+            if (log.testName) {
+                stats.byTest[log.testName] = (stats.byTest[log.testName] || 0) + 1;
+            }
+        }
+        return stats;
+    }
+}

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

@@ -0,0 +1,70 @@
+/**
+ * 🔧 TestMethodLogger - Helper para logs visuais organizados
+ *
+ * Facilita a criação de logs com separação visual clara entre métodos
+ * para melhor debugging e acompanhamento de execução de testes.
+ */
+export declare class TestMethodLogger {
+    /**
+     * 🚀 Executa um método com logs automáticos de início/fim
+     *
+     * @example
+     * await TestMethodLogger.run('getTokenSFA', 'StatementsTokenSFA', async () => {
+     *   return await new StatementsTokenSFA().getTokenSFA("mve.svc", "yUqFQ3Hkwx9Gd8-U");
+     * }, ["mve.svc", "yUqFQ3Hkwx9Gd8-U"]);
+     */
+    static run<T>(methodName: string, className: string, method: () => Promise<T> | T, params?: any[]): Promise<T>;
+    /**
+     * 📋 Log simples de início de método (sem wrapper)
+     *
+     * @example
+     * TestMethodLogger.start('getTokenSFA', 'StatementsTokenSFA', ["mve.svc", "yUqFQ3Hkwx9Gd8-U"]);
+     */
+    static start(methodName: string, className: string, params?: any[]): void;
+    /**
+     * ✅ Log de fim de método (sem wrapper)
+     *
+     * @example
+     * TestMethodLogger.end('getTokenSFA', 'StatementsTokenSFA', true, 1500);
+     */
+    static end(methodName: string, className: string, success?: boolean, duration?: number): void;
+    /**
+     * 🎯 Separador de seção para grupos de métodos relacionados
+     *
+     * @example
+     * TestMethodLogger.section('CRIAÇÃO DE MASSA SFA');
+     */
+    static section(sectionName: string): void;
+    /**
+     * 📖 Log simples para método sem timing
+     *
+     * @example
+     * TestMethodLogger.log('validarCNPJ', 'StatementsValidarCNPJ');
+     */
+    static log(methodName: string, className: string): void;
+}
+/**
+ * 🎨 Decorator para métodos (TypeScript Experimental)
+ *
+ * @example
+ * class StatementsTokenSFA {
+ *   @logMethod('StatementsTokenSFA')
+ *   async getTokenSFA(service: string, token: string) {
+ *     // sua implementação aqui
+ *   }
+ * }
+ */
+export declare function logMethod(className: string): (target: any, propertyName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * 🚀 Helper para executar uma sequência de métodos com logs organizados
+ *
+ * @example
+ * await TestMethodSequence.execute('GERAÇÃO MASSA SFA', [
+ *   ['getTokenSFA', 'StatementsTokenSFA', () => new StatementsTokenSFA().getTokenSFA("mve.svc", "yUqFQ3Hkwx9Gd8-U")],
+ *   ['geroOuReceboCNPJ', 'StatementsValidarCNPJ', () => new StatementsValidarCNPJ().geroOuReceboCNPJ()],
+ *   ['criacaoCliente', 'StatementsCriarCliente', () => new StatementsCriarCliente().criacaoCliente("Criação de Cliente FTTH", "MPJ00081891", "a0081891")]
+ * ]);
+ */
+export declare class TestMethodSequence {
+    static execute(sectionName: string, methods: Array<[string, string, () => Promise<any> | any, any[]?]>): Promise<void>;
+}

package/dist/src/utils/TestMethodLogger.js

@@ -0,0 +1,95 @@
+/**
+ * 🔧 TestMethodLogger - Helper para logs visuais organizados
+ *
+ * Facilita a criação de logs com separação visual clara entre métodos
+ * para melhor debugging e acompanhamento de execução de testes.
+ */
+import { ConfigLogger } from './ConfigLogger.js';
+export class TestMethodLogger {
+    /**
+     * 🚀 Executa um método com logs automáticos de início/fim
+     *
+     * @example
+     * await TestMethodLogger.run('getTokenSFA', 'StatementsTokenSFA', async () => {
+     *   return await new StatementsTokenSFA().getTokenSFA("mve.svc", "yUqFQ3Hkwx9Gd8-U");
+     * }, ["mve.svc", "yUqFQ3Hkwx9Gd8-U"]);
+     */
+    static async run(methodName, className, method, params) {
+        return await ConfigLogger.executeWithLogs(methodName, className, method, params);
+    }
+    /**
+     * 📋 Log simples de início de método (sem wrapper)
+     *
+     * @example
+     * TestMethodLogger.start('getTokenSFA', 'StatementsTokenSFA', ["mve.svc", "yUqFQ3Hkwx9Gd8-U"]);
+     */
+    static start(methodName, className, params) {
+        ConfigLogger.methodStart(methodName, className, params);
+    }
+    /**
+     * ✅ Log de fim de método (sem wrapper)
+     *
+     * @example
+     * TestMethodLogger.end('getTokenSFA', 'StatementsTokenSFA', true, 1500);
+     */
+    static end(methodName, className, success = true, duration) {
+        ConfigLogger.methodEnd(methodName, className, success, duration);
+    }
+    /**
+     * 🎯 Separador de seção para grupos de métodos relacionados
+     *
+     * @example
+     * TestMethodLogger.section('CRIAÇÃO DE MASSA SFA');
+     */
+    static section(sectionName) {
+        ConfigLogger.sectionSeparator(sectionName);
+    }
+    /**
+     * 📖 Log simples para método sem timing
+     *
+     * @example
+     * TestMethodLogger.log('validarCNPJ', 'StatementsValidarCNPJ');
+     */
+    static log(methodName, className) {
+        ConfigLogger.methodLog(methodName, className);
+    }
+}
+/**
+ * 🎨 Decorator para métodos (TypeScript Experimental)
+ *
+ * @example
+ * class StatementsTokenSFA {
+ *   @logMethod('StatementsTokenSFA')
+ *   async getTokenSFA(service: string, token: string) {
+ *     // sua implementação aqui
+ *   }
+ * }
+ */
+export function logMethod(className) {
+    return (target, propertyName, descriptor) => {
+        const method = descriptor.value;
+        descriptor.value = async function (...args) {
+            return await TestMethodLogger.run(propertyName, className, () => method.apply(this, args), args);
+        };
+        return descriptor;
+    };
+}
+/**
+ * 🚀 Helper para executar uma sequência de métodos com logs organizados
+ *
+ * @example
+ * await TestMethodSequence.execute('GERAÇÃO MASSA SFA', [
+ *   ['getTokenSFA', 'StatementsTokenSFA', () => new StatementsTokenSFA().getTokenSFA("mve.svc", "yUqFQ3Hkwx9Gd8-U")],
+ *   ['geroOuReceboCNPJ', 'StatementsValidarCNPJ', () => new StatementsValidarCNPJ().geroOuReceboCNPJ()],
+ *   ['criacaoCliente', 'StatementsCriarCliente', () => new StatementsCriarCliente().criacaoCliente("Criação de Cliente FTTH", "MPJ00081891", "a0081891")]
+ * ]);
+ */
+export class TestMethodSequence {
+    static async execute(sectionName, methods) {
+        TestMethodLogger.section(sectionName);
+        for (const [methodName, className, method, params] of methods) {
+            await TestMethodLogger.run(methodName, className, method, params);
+        }
+        ConfigLogger.success(`✅ Seção ${sectionName} concluída com sucesso!`);
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare class UnifiedTeardown {
+    static run(): Promise<void>;
+}
+export default function playwrightTeardown(): Promise<void>;