@silasfmartins/testhub 1.0.0

package/dist/src/utils/EvidenceCapture.js

@@ -0,0 +1,600 @@
+/**
+ * 📸 Sistema de Captura de Evidências
+ * @description Captura e organiza screenshots e logs para gerar relatórios com evidências
+ * @author TestHUB Team
+ * @version 1.0.0
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { TestContext } from '../testContext/TestContext.js';
+import { Logger } from './Logger.js';
+export class EvidenceCapture {
+    static evidenceByTest = new Map();
+    static currentEvidenceId = 0;
+    static playwrightReportDir = '';
+    static evidenceFile = '';
+    /**
+     * ✅ Inicializa o sistema de captura de evidências
+     */
+    static initialize() {
+        // Detectar diretório playwright-report
+        const possibleDirs = [
+            path.join(process.cwd(), 'playwright-report'),
+            path.join(process.cwd(), 'test-results'),
+            path.join(process.cwd(), 'reports'),
+        ];
+        for (const dir of possibleDirs) {
+            if (fs.existsSync(dir)) {
+                EvidenceCapture.playwrightReportDir = dir;
+                break;
+            }
+        }
+        // Se não encontrar, criar playwright-report
+        if (!EvidenceCapture.playwrightReportDir) {
+            EvidenceCapture.playwrightReportDir = path.join(process.cwd(), 'playwright-report');
+            if (!fs.existsSync(EvidenceCapture.playwrightReportDir)) {
+                fs.mkdirSync(EvidenceCapture.playwrightReportDir, { recursive: true });
+            }
+        }
+        // Criar subpasta para evidências
+        const evidenceDir = path.join(EvidenceCapture.playwrightReportDir, 'evidence');
+        if (!fs.existsSync(evidenceDir)) {
+            fs.mkdirSync(evidenceDir, { recursive: true });
+        }
+        // Definir arquivo de persistência
+        EvidenceCapture.evidenceFile = path.join(EvidenceCapture.playwrightReportDir, 'evidence-data.json');
+        // Carregar evidências existentes
+        EvidenceCapture.loadEvidence();
+    }
+    /**
+     * 🆕 Carregar evidências do arquivo de persistência
+     */
+    static loadEvidence() {
+        try {
+            if (fs.existsSync(EvidenceCapture.evidenceFile)) {
+                const data = fs.readFileSync(EvidenceCapture.evidenceFile, 'utf-8');
+                const parsed = JSON.parse(data);
+                // Restaurar Map
+                if (parsed.evidenceByTest) {
+                    for (const [testName, testEvidence] of Object.entries(parsed.evidenceByTest)) {
+                        // Converter datas de volta para objetos Date
+                        const evidence = testEvidence;
+                        evidence.startTime = new Date(evidence.startTime);
+                        if (evidence.endTime) {
+                            evidence.endTime = new Date(evidence.endTime);
+                        }
+                        if (evidence.items) {
+                            evidence.items.forEach((item) => {
+                                item.timestamp = new Date(item.timestamp);
+                            });
+                        }
+                        EvidenceCapture.evidenceByTest.set(testName, evidence);
+                    }
+                }
+                else {
+                    Logger.info('⚠️ [EvidenceCapture] loadEvidence - No evidenceByTest in parsed data');
+                }
+                // Restaurar contador
+                if (parsed.currentEvidenceId) {
+                    EvidenceCapture.currentEvidenceId = parsed.currentEvidenceId;
+                }
+            }
+            else {
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [EvidenceCapture] Erro ao carregar evidências: ${error}`);
+        }
+    }
+    /**
+     * 🆕 Salvar evidências no arquivo de persistência
+     */
+    static saveEvidence() {
+        try {
+            const data = {
+                evidenceByTest: Object.fromEntries(EvidenceCapture.evidenceByTest),
+                currentEvidenceId: EvidenceCapture.currentEvidenceId,
+                lastSaved: new Date().toISOString(),
+            };
+            fs.writeFileSync(EvidenceCapture.evidenceFile, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch (error) {
+            Logger.warning(`⚠️ [EvidenceCapture] Erro ao salvar evidências: ${error}`);
+        }
+    }
+    /**
+     * ✅ Inicia captura para um teste
+     */
+    static startTest(testName) {
+        if (!EvidenceCapture.evidenceByTest.has(testName)) {
+            EvidenceCapture.evidenceByTest.set(testName, {
+                testName,
+                startTime: new Date(),
+                items: [],
+                totalActions: 0,
+                successActions: 0,
+                failedActions: 0,
+            });
+            // Salvar imediatamente
+            EvidenceCapture.saveEvidence();
+        }
+    }
+    /**
+     * ✅ Finaliza captura para um teste
+     */
+    static endTest(testName) {
+        const evidence = EvidenceCapture.evidenceByTest.get(testName);
+        if (evidence) {
+            evidence.endTime = new Date();
+            // Salvar imediatamente
+            EvidenceCapture.saveEvidence();
+        }
+    }
+    /**
+     * ✅ Captura uma ação com screenshot
+     * @param testName Nome do teste
+     * @param action Ação executada
+     * @param description Descrição da ação
+     * @param metadata Metadados opcionais
+     * @param providedScreenshot Screenshot fornecido externamente (Buffer ou caminho)
+     */
+    static async captureAction(testName, action, description, metadata, providedScreenshot) {
+        try {
+            // Garantir que o teste está iniciado
+            EvidenceCapture.startTest(testName);
+            const evidenceId = `evidence-${++EvidenceCapture.currentEvidenceId}`;
+            const timestamp = new Date();
+            // Capturar screenshot se possível
+            let screenshot;
+            let screenshotPath;
+            try {
+                // 🆕 PRIORIZAR SCREENSHOT FORNECIDO (Mobile/Web)
+                if (providedScreenshot) {
+                    if (Buffer.isBuffer(providedScreenshot)) {
+                        screenshot = providedScreenshot;
+                    }
+                    else if (typeof providedScreenshot === 'string') {
+                        // Se for caminho, usar o caminho diretamente
+                        screenshotPath = providedScreenshot;
+                    }
+                }
+                // Se não tiver screenshot fornecido, tentar capturar via TestContext
+                if (!(screenshot || screenshotPath)) {
+                    const capturedScreenshot = await TestContext.captureScreenshot();
+                    if (capturedScreenshot) {
+                        screenshot = capturedScreenshot;
+                    }
+                }
+                // Se tiver screenshot buffer, salvar arquivo
+                if (screenshot) {
+                    const evidenceDir = path.join(EvidenceCapture.playwrightReportDir, 'evidence', testName.replace(/[^a-zA-Z0-9]/g, '_'));
+                    if (!fs.existsSync(evidenceDir)) {
+                        fs.mkdirSync(evidenceDir, { recursive: true });
+                    }
+                    const screenshotFile = path.join(evidenceDir, `${evidenceId}.png`);
+                    fs.writeFileSync(screenshotFile, screenshot);
+                    // Path relativo para o HTML
+                    screenshotPath = `evidence/${testName.replace(/[^a-zA-Z0-9]/g, '_')}/${evidenceId}.png`;
+                }
+            }
+            catch (error) {
+                Logger.warning(`⚠️ Não foi possível capturar screenshot para ${action}: ${error}`);
+            }
+            const evidenceItem = {
+                id: evidenceId,
+                timestamp,
+                testName,
+                action,
+                description,
+                screenshot,
+                screenshotPath,
+                metadata,
+            };
+            const evidence = EvidenceCapture.evidenceByTest.get(testName);
+            evidence.items.push(evidenceItem);
+            evidence.totalActions++;
+            // Determinar se ação foi bem-sucedida baseado na descrição
+            if (description.includes('❌') ||
+                description.includes('erro') ||
+                description.includes('falhou')) {
+                evidence.failedActions++;
+            }
+            else {
+                evidence.successActions++;
+            }
+            // 🆕 SALVAR IMEDIATAMENTE APÓS ADICIONAR EVIDÊNCIA
+            EvidenceCapture.saveEvidence();
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao capturar evidência:', error);
+        }
+    }
+    /**
+     * Compatibilidade: capturar página (wrapper para captureAction)
+     * @param description descrição da captura
+     * @param providedScreenshot buffer ou path opcional
+     */
+    static async capturePage(description, providedScreenshot) {
+        try {
+            const testInfo = TestContext.getSafeTestInfo();
+            const testName = (testInfo && testInfo.title) || 'unknown';
+            await EvidenceCapture.captureAction(testName, 'page', description, undefined, providedScreenshot);
+        }
+        catch (e) {
+            Logger.warning(`⚠️ EvidenceCapture.capturePage falhou: ${e}`);
+        }
+    }
+    /**
+     * ✅ Obtém evidências de um teste
+     */
+    static getTestEvidence(testName) {
+        return EvidenceCapture.evidenceByTest.get(testName);
+    }
+    /**
+     * ✅ Obtém todas as evidências (sempre carrega dados atualizados quando Map está vazio)
+     */
+    static getAllEvidence() {
+        // 🆕 RECARREGAR dados do arquivo APENAS se o Map estiver vazio
+        if (EvidenceCapture.evidenceByTest.size === 0) {
+            EvidenceCapture.loadEvidence();
+        }
+        return EvidenceCapture.evidenceByTest;
+    }
+    /**
+     * ✅ Gera relatório HTML com evidências
+     */
+    static async generateEvidenceReport() {
+        try {
+            const reportPath = path.join(EvidenceCapture.playwrightReportDir, 'evidence-report.html');
+            const html = EvidenceCapture.generateEvidenceHTML();
+            fs.writeFileSync(reportPath, html, 'utf-8');
+            Logger.success(`📄 Relatório de evidências gerado: ${reportPath}`);
+        }
+        catch (error) {
+            Logger.error('❌ Erro ao gerar relatório de evidências:', error);
+        }
+    }
+    /**
+     * ✅ Gera HTML do relatório de evidências
+     */
+    static generateEvidenceHTML() {
+        const allEvidence = Array.from(EvidenceCapture.evidenceByTest.values());
+        // Agrupar por tipo de teste e status
+        const groupedEvidence = allEvidence.reduce((groups, evidence) => {
+            // Detectar tipo de teste baseado no nome
+            let testType = 'Geral';
+            if (evidence.testName.toLowerCase().includes('api'))
+                testType = 'API';
+            else if (evidence.testName.toLowerCase().includes('frontend'))
+                testType = 'Frontend';
+            else if (evidence.testName.toLowerCase().includes('mobile'))
+                testType = 'Mobile';
+            else if (evidence.testName.toLowerCase().includes('ssh'))
+                testType = 'SSH';
+            else if (evidence.testName.toLowerCase().includes('banco'))
+                testType = 'Banco';
+            if (!groups[testType])
+                groups[testType] = [];
+            groups[testType].push(evidence);
+            return groups;
+        }, {});
+        const totalTests = allEvidence.length;
+        const totalActions = allEvidence.reduce((sum, e) => sum + e.totalActions, 0);
+        const successActions = allEvidence.reduce((sum, e) => sum + e.successActions, 0);
+        const failedActions = allEvidence.reduce((sum, e) => sum + e.failedActions, 0);
+        const successRate = totalActions > 0
+            ? ((successActions / totalActions) * 100).toFixed(1)
+            : '0.0';
+        return `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>📸 Relatório de Evidências - TestHUB</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { font-family: 'Segoe UI', system-ui, sans-serif; background: #0f172a; color: #f1f5f9; line-height: 1.6; }
+        .light-mode { background-color: #f9fafb !important; color: #111827 !important; }
+        .container { max-width: 1200px; margin: 0 auto; padding: 2rem; }
+        .header { text-align: center; margin-bottom: 3rem; padding: 2rem; background: linear-gradient(135deg, #1e293b, #334155); border-radius: 1rem; }
+        .header h1 { color: #22d3ee; font-size: 2.5rem; margin-bottom: 0.5rem; }
+        .header p { color: #94a3b8; font-size: 1.1rem; margin-bottom: 1rem; }
+        .header-buttons { margin-top: 1rem; display: flex; gap: 1rem; justify-content: center; flex-wrap: wrap; }
+        .btn { background: #10b981; color: white; border: none; padding: 0.75rem 1.5rem; border-radius: 0.5rem; cursor: pointer; font-size: 1rem; font-weight: 600; transition: all 0.3s ease; }
+        .btn:hover { background: #059669; transform: translateY(-2px); }
+        .btn-theme { background: #3b82f6; }
+        .btn-theme:hover { background: #2563eb; }
+        
+        /* Agrupamento por tipo */
+        .type-group { margin-bottom: 3rem; background: #1e293b; border-radius: 1rem; padding: 1.5rem; }
+        .type-header { display: flex; items-center justify-between; margin-bottom: 2rem; padding-bottom: 1rem; border-bottom: 2px solid #374151; }
+        .type-title { font-size: 1.8rem; font-weight: 700; display: flex; items-center gap: 0.5rem; }
+        .type-stats { display: flex; gap: 1rem; font-size: 0.9rem; }
+        .stat-item { background: #374151; padding: 0.5rem 1rem; border-radius: 0.5rem; }
+        .stat-success { color: #10b981; }
+        .stat-failed { color: #ef4444; }
+        .stat-total { color: #06b6d4; }
+        
+        .tests-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 2rem; }
+        .test-card { background: #111827; border-radius: 0.75rem; overflow: hidden; border: 1px solid #374151; }
+        .test-card-header { background: #1f2937; padding: 1rem; }
+        .test-title { color: #22d3ee; font-size: 1.2rem; font-weight: 600; margin-bottom: 0.5rem; }
+        .test-meta { display: grid; grid-template-columns: repeat(2, 1fr); gap: 0.5rem; font-size: 0.85rem; color: #9ca3af; }
+        .test-meta-item { background: #374151; padding: 0.5rem; border-radius: 0.25rem; text-align: center; }
+        
+        .actions-container { padding: 1rem; }
+        .action-item { background: #1f2937; border-radius: 0.5rem; margin-bottom: 1rem; overflow: hidden; }
+        .action-header { display: flex; justify-content: between; align-items: center; padding: 0.75rem; background: #374151; }
+        .action-title { color: #22c55e; font-weight: 600; flex-1; }
+        .action-time { color: #94a3b8; font-size: 0.8rem; }
+        .action-status { font-size: 0.7rem; padding: 0.25rem 0.5rem; border-radius: 0.25rem; margin-left: 0.5rem; }
+        .status-success { background: #059669; color: white; }
+        .status-failed { background: #dc2626; color: white; }
+        .action-description { color: #e2e8f0; padding: 0.75rem; font-size: 0.9rem; }
+        .screenshot-container { padding: 0.75rem; text-align: center; }
+        .screenshot { max-width: 100%; max-height: 200px; border-radius: 0.5rem; box-shadow: 0 4px 6px rgba(0,0,0,0.3); cursor: pointer; transition: transform 0.2s; }
+        .screenshot:hover { transform: scale(1.05); }
+        .no-screenshot { color: #64748b; font-style: italic; padding: 1rem; text-align: center; background: #374151; border-radius: 0.25rem; }
+        
+        .summary-stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1.5rem; margin: 3rem 0; }
+        .summary-card { background: linear-gradient(135deg, #1e293b, #334155); padding: 2rem; border-radius: 1rem; text-align: center; }
+        .summary-number { font-size: 2.5rem; font-weight: bold; margin-bottom: 0.5rem; }
+        .summary-label { color: #94a3b8; font-weight: 500; }
+        .summary-tests { color: #06b6d4; }
+        .summary-actions { color: #22d3ee; }
+        .summary-success { color: #10b981; }
+        .summary-failed { color: #ef4444; }
+        
+        .collapsible { cursor: pointer; user-select: none; }
+        .collapsible:hover { background: #1f2937; }
+        .content { max-height: 300px; overflow-y: auto; }
+        
+        @media (max-width: 768px) {
+            .header-buttons { flex-direction: column; align-items: center; }
+            .tests-grid { grid-template-columns: 1fr; }
+            .type-header { flex-direction: column; gap: 1rem; }
+            .type-stats { flex-wrap: wrap; justify-content: center; }
+        }
+    </style>
+</head>
+<body id="body-root">
+    <div class="container">
+        <div class="header">
+            <h1>📸 Relatório de Evidências TestHUB</h1>
+            <p>Documentação visual completa dos testes executados</p>
+            <div class="header-buttons">
+                <button onclick="toggleTheme()" class="btn btn-theme">🌙 Alternar Tema</button>
+                <button onclick="generatePDF()" class="btn">📄 Gerar PDF</button>
+                <button onclick="printPage()" class="btn">🖨️ Imprimir</button>
+            </div>
+        </div>
+
+        <!-- Estatísticas Resumidas -->
+        <div class="summary-stats">
+            <div class="summary-card">
+                <div class="summary-number summary-tests">${totalTests}</div>
+                <div class="summary-label">Testes com Evidências</div>
+            </div>
+            <div class="summary-card">
+                <div class="summary-number summary-actions">${totalActions}</div>
+                <div class="summary-label">Total de Ações</div>
+            </div>
+            <div class="summary-card">
+                <div class="summary-number summary-success">${successActions}</div>
+                <div class="summary-label">Ações Bem-sucedidas</div>
+            </div>
+            <div class="summary-card">
+                <div class="summary-number summary-failed">${failedActions}</div>
+                <div class="summary-label">Ações com Falha</div>
+            </div>
+            <div class="summary-card">
+                <div class="summary-number" style="color: ${Number.parseFloat(successRate) >= 80 ? '#10b981' : Number.parseFloat(successRate) >= 60 ? '#f59e0b' : '#ef4444'}">${successRate}%</div>
+                <div class="summary-label">Taxa de Sucesso</div>
+            </div>
+        </div>
+
+        <!-- Agrupamento por Tipo de Teste -->
+        ${Object.entries(groupedEvidence)
+            .map(([testType, evidences]) => `
+            <div class="type-group">
+                <div class="type-header">
+                    <div class="type-title">
+                        ${EvidenceCapture.getTypeIcon(testType)} ${testType}
+                        <span style="font-size: 0.8rem; color: #9ca3af;">(${evidences.length} teste${evidences.length > 1 ? 's' : ''})</span>
+                    </div>
+                    <div class="type-stats">
+                        <div class="stat-item stat-total">
+                            📊 ${evidences.reduce((sum, e) => sum + e.totalActions, 0)} ações
+                        </div>
+                        <div class="stat-item stat-success">
+                            ✅ ${evidences.reduce((sum, e) => sum + e.successActions, 0)} sucessos
+                        </div>
+                        <div class="stat-item stat-failed">
+                            ❌ ${evidences.reduce((sum, e) => sum + e.failedActions, 0)} falhas
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="tests-grid">
+                    ${evidences
+            .map((evidence) => `
+                        <div class="test-card">
+                            <div class="test-card-header collapsible" onclick="toggleTestContent('${evidence.testName.replace(/[^a-zA-Z0-9]/g, '_')}')">
+                                <div class="test-title">
+                                    🧪 ${evidence.testName}
+                                    <span id="toggle-${evidence.testName.replace(/[^a-zA-Z0-9]/g, '_')}" style="float: right;">📋</span>
+                                </div>
+                                <div class="test-meta">
+                                    <div class="test-meta-item">
+                                        <strong>Início:</strong><br>${evidence.startTime.toLocaleString('pt-BR')}
+                                    </div>
+                                    <div class="test-meta-item">
+                                        <strong>Fim:</strong><br>${evidence.endTime?.toLocaleString('pt-BR') || 'Em execução'}
+                                    </div>
+                                    <div class="test-meta-item">
+                                        <strong>Total de Ações:</strong><br><span class="stat-total">${evidence.totalActions}</span>
+                                    </div>
+                                    <div class="test-meta-item">
+                                        <strong>Taxa de Sucesso:</strong><br>
+                                        <span style="color: ${((evidence.successActions / evidence.totalActions) * 100) >= 80 ? '#10b981' : '#f59e0b'}">
+                                            ${((evidence.successActions / evidence.totalActions) * 100).toFixed(1)}%
+                                        </span>
+                                    </div>
+                                </div>
+                            </div>
+                            
+                            <div id="content-${evidence.testName.replace(/[^a-zA-Z0-9]/g, '_')}" class="actions-container content" style="display: none;">
+                                ${evidence.items
+            .map((item, index) => `
+                                    <div class="action-item">
+                                        <div class="action-header">
+                                            <div class="action-title">
+                                                <span style="color: #9ca3af; font-size: 0.8rem; margin-right: 0.5rem;">#${index + 1}</span>
+                                                🎯 ${item.action}
+                                            </div>
+                                            <div class="action-time">${item.timestamp.toLocaleTimeString('pt-BR')}</div>
+                                            <div class="action-status ${item.success ? 'status-success' : 'status-failed'}">
+                                                ${item.success ? '✅' : '❌'}
+                                            </div>
+                                        </div>
+                                        <div class="action-description">${item.description}</div>
+                                        <div class="screenshot-container">
+                                            ${item.screenshotPath
+            ? `<img src="${item.screenshotPath}" alt="Screenshot da ação ${item.action}" class="screenshot" onclick="openImageModal('${item.screenshotPath}')">`
+            : `<div class="no-screenshot">📷 Screenshot não disponível para esta ação</div>`}
+                                        </div>
+                                    </div>
+                                `)
+            .join('')}
+                            </div>
+                        </div>
+                    `)
+            .join('')}
+                </div>
+            </div>
+        `)
+            .join('')}
+    </div>
+    
+    <!-- Modal para visualização de imagem -->
+    <div id="imageModal" style="display: none; position: fixed; z-index: 1000; left: 0; top: 0; width: 100%; height: 100%; background: rgba(0,0,0,0.9);" onclick="closeImageModal()">
+        <div style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); max-width: 90%; max-height: 90%;">
+            <img id="modalImage" style="max-width: 100%; max-height: 100%; border-radius: 0.5rem;">
+        </div>
+        <span style="position: absolute; top: 15px; right: 35px; color: #f1f5f9; font-size: 40px; font-weight: bold; cursor: pointer;" onclick="closeImageModal()">&times;</span>
+    </div>
+    
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jspdf/2.5.1/jspdf.umd.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/html2canvas/1.4.1/html2canvas.min.js"></script>
+    <script>
+        function toggleTheme() {
+            document.getElementById('body-root').classList.toggle('light-mode')
+        }
+        
+        function toggleTestContent(testId) {
+            const content = document.getElementById('content-' + testId)
+            const toggle = document.getElementById('toggle-' + testId)
+            
+            if (content.style.display === 'none') {
+                content.style.display = 'block'
+                toggle.innerHTML = '📋 ▲'
+            } else {
+                content.style.display = 'none'
+                toggle.innerHTML = '📋'
+            }
+        }
+        
+        function openImageModal(imageSrc) {
+            document.getElementById('modalImage').src = imageSrc
+            document.getElementById('imageModal').style.display = 'block'
+        }
+        
+        function closeImageModal() {
+            document.getElementById('imageModal').style.display = 'none'
+        }
+    
+        async function generatePDF() {
+            const element = document.body;
+            
+            // Aplicar estilos para PDF
+            const originalBg = element.style.background;
+            const originalColor = element.style.color;
+            element.style.background = 'white';
+            element.style.color = 'black';
+            
+            try {
+                // Usar html2canvas para capturar o conteúdo
+                const canvas = await html2canvas(element, {
+                    scale: 1.5,
+                    useCORS: false,
+                    allowTaint: true,
+                    backgroundColor: '#fff'
+                });
+                
+                // Criar PDF com jsPDF
+                const { jsPDF } = jspdf;
+                const pdf = new jsPDF({
+                    orientation: 'portrait',
+                    unit: 'mm',
+                    format: 'a4'
+                });
+                
+                const imgData = canvas.toDataURL('image/jpeg', 0.98);
+                const imgWidth = 210;
+                const pageHeight = 297;
+                const imgHeight = (canvas.height * imgWidth) / canvas.width;
+                let heightLeft = imgHeight;
+                let position = 0;
+                
+                pdf.addImage(imgData, 'JPEG', 0, position, imgWidth, imgHeight);
+                heightLeft -= pageHeight;
+                
+                while (heightLeft > 0) {
+                    position = heightLeft - imgHeight;
+                    pdf.addPage();
+                    pdf.addImage(imgData, 'JPEG', 0, position, imgWidth, imgHeight);
+                    heightLeft -= pageHeight;
+                }
+                
+                pdf.save('evidencias-testhub-' + new Date().toISOString().split('T')[0] + '.pdf');
+            } catch (error) {
+                console.error('Erro ao gerar PDF:', error);
+                alert('Erro ao gerar PDF: ' + error.message);
+            } finally {
+                // Restaurar estilos originais
+                element.style.background = originalBg;
+                element.style.color = originalColor;
+            }
+        }
+        
+        function printPage() {
+            window.print();
+        }
+    </script>
+</body>
+</html>`;
+    }
+    /**
+     * ✅ Obter ícone do tipo de teste
+     */
+    static getTypeIcon(testType) {
+        const icons = {
+            API: '🌐',
+            Frontend: '💻',
+            Mobile: '📱',
+            SSH: '🔧',
+            Banco: '🗃️',
+            Geral: '📋',
+        };
+        return icons[testType] || '📋';
+    }
+    /**
+     * ✅ Limpa evidências antigas
+     */
+    static cleanup() {
+        EvidenceCapture.evidenceByTest.clear();
+        EvidenceCapture.currentEvidenceId = 0;
+    }
+}
+// ✅ Auto-inicialização
+EvidenceCapture.initialize();

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

@@ -0,0 +1,70 @@
+/**
+ * 📸 Organizador de Evidências do AutoCore
+ * @description Coleta e organiza screenshots já gerados pelos projetos consumidores (Web/Mobile)
+ * @author TestHUB Team
+ * @version 1.0.0
+ *
+ * ⚠️ IMPORTANTE: Este projeto AutoCore NÃO gera evidências
+ * Ele apenas coleta e organiza evidências dos projetos consumidores:
+ * - Web: C:\Users\{user}\PlayWright\test-simplifique-e2e\test-results\web-screenshots\
+ * - Mobile: C:\Users\{user}\PlayWright\mobile\test-results\mobile-screenshots\
+ */
+export interface EvidenceScreenshot {
+    fileName: string;
+    fullPath: string;
+    relativePath: string;
+    testName: string;
+    timestamp: Date;
+    size: number;
+    base64?: string;
+}
+export declare class EvidenceReportGenerator {
+    /**
+     * 🎯 Detectar o tipo do projeto atual baseado nas pastas de evidências
+     *
+     * ℹ️ AutoCore trabalha no projeto atual e verifica se há:
+     * - Web: test-results/web-screenshots/
+     * - Mobile: test-results/mobile-screenshots/
+     */
+    private static detectCurrentProjectType;
+    /**
+     * 🔍 Coleta screenshots em uma pasta específica do projeto consumidor
+     */
+    private static findScreenshotsInDirectory;
+    /**
+     * ✅ Gera relatório de evidências procurando screenshots nas pastas padrão
+     */
+    static generateEvidenceReport(): Promise<void>;
+    /**
+     * ✅ Procura screenshots em diretórios específicos
+     */
+    private static findScreenshots;
+    /**
+     * 🆕 Converte imagem para base64
+     */
+    private static convertImageToBase64;
+    /**
+     * ✅ Encontra arquivos recursivamente
+     */
+    private static findFilesRecursively;
+    /**
+     * ✅ Extrai nome do teste do caminho ou nome do arquivo
+     */
+    private static extractTestName;
+    /**
+     * ✅ Gera HTML do relatório com recursos avançados (igual HTMLTemplate)
+     */
+    private static generateHTML;
+    /**
+     * ✅ Agrupa screenshots por teste
+     */
+    private static groupScreenshotsByTest;
+    /**
+     * ✅ Formata tamanho de arquivo
+     */
+    private static formatFileSize;
+    /**
+     * ✅ Gera relatório vazio quando não há evidências nos projetos consumidores
+     */
+    private static generateEmptyReport;
+}