@silasfmartins/testhub 1.0.0

package/dist/src/appium/DeviceFarmViewer.js

@@ -0,0 +1,1083 @@
+/**
+ * 📱 Sistema de Visualização Integrada para DeviceFarm
+ * @description Integra visualização local com o DeviceFarm remoto com detecção automática de projetos consumidores
+ * @author AutoCore Team
+ * @version 2.0.0
+ */
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { execSync } from 'node:child_process';
+import { cwd } from 'node:process';
+// Logger simples para evitar dependências circulares
+const SimpleLogger = {
+    info: (message) => console.log(`ℹ️  ${message}`),
+    warning: (message) => console.warn(`⚠️  ${message}`),
+    error: (message) => console.error(`❌ ${message}`),
+};
+/**
+ * 📱 DeviceFarm Viewer com suporte a projetos consumidores
+ */
+export class DeviceFarmViewer {
+    // Estado interno
+    static isActive = false;
+    static session = null;
+    static stepCounter = 0;
+    static consumerProjectPath = null;
+    /**
+     * 🎯 Configura projeto consumidor automaticamente
+     */
+    static async setupConsumerProject() {
+        try {
+            const currentPath = cwd();
+            // Detectar se estamos em um projeto consumidor (não autocore)
+            if (!currentPath.includes('autocore') &&
+                existsSync(join(currentPath, 'package.json'))) {
+                const packageJson = JSON.parse(readFileSync(join(currentPath, 'package.json'), 'utf8'));
+                // Verificar se tem dependência do autocore
+                const hasAutocore = packageJson.dependencies?.['comp-autocore-v1'] ||
+                    packageJson.devDependencies?.['comp-autocore-v1'];
+                if (hasAutocore) {
+                    DeviceFarmViewer.consumerProjectPath = currentPath;
+                    SimpleLogger.info(`🎯 Projeto consumidor detectado: ${basename(currentPath)}`);
+                    // Criar diretório de screenshots no consumidor se não existir
+                    const consumerScreenshotPath = join(currentPath, 'test-results', 'mobile-screenshots');
+                    if (!existsSync(consumerScreenshotPath)) {
+                        mkdirSync(consumerScreenshotPath, { recursive: true });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            SimpleLogger.warning(`⚠️ Erro ao configurar projeto consumidor: ${String(error)}`);
+        }
+    }
+    /**
+     * 🔄 Sincroniza screenshots do projeto consumidor para o viewer
+     */
+    static async syncConsumerScreenshots() {
+        if (!DeviceFarmViewer.consumerProjectPath) {
+            return;
+        }
+        try {
+            const consumerScreenshotPath = join(DeviceFarmViewer.consumerProjectPath, 'test-results', 'mobile-screenshots');
+            const viewerScreenshotPath = join('./test-results/mobile-viewer/screenshots');
+            // Criar diretório do viewer se não existir
+            if (!existsSync(viewerScreenshotPath)) {
+                mkdirSync(viewerScreenshotPath, { recursive: true });
+            }
+            // Sincronizar screenshots
+            if (existsSync(consumerScreenshotPath)) {
+                const screenshots = readdirSync(consumerScreenshotPath).filter((file) => file.endsWith('.png') || file.endsWith('.jpg'));
+                let syncedCount = 0;
+                for (const screenshot of screenshots) {
+                    const sourcePath = join(consumerScreenshotPath, screenshot);
+                    const destPath = join(viewerScreenshotPath, screenshot);
+                    // Copiar apenas se não existir ou se for mais recente
+                    if (!existsSync(destPath) ||
+                        statSync(sourcePath).mtime > statSync(destPath).mtime) {
+                        copyFileSync(sourcePath, destPath);
+                        syncedCount++;
+                        // Adicionar ao viewer se ainda não estiver
+                        DeviceFarmViewer.addScreenshotFromSync(screenshot, `Sync ${syncedCount}`);
+                    }
+                }
+                if (syncedCount > 0) {
+                    SimpleLogger.info(`🔄 Sincronizados ${syncedCount} screenshots do projeto consumidor`);
+                }
+            }
+        }
+        catch (error) {
+            SimpleLogger.warning(`⚠️ Erro ao sincronizar screenshots: ${String(error)}`);
+        }
+    }
+    /**
+     * 📸 Adiciona screenshot sincronizado
+     */
+    static addScreenshotFromSync(filename, description) {
+        if (!(DeviceFarmViewer.isActive && DeviceFarmViewer.session))
+            return;
+        // Verificar se já existe
+        const exists = DeviceFarmViewer.session.screenshots.some((s) => s.filename === filename);
+        if (exists)
+            return;
+        const screenshot = {
+            timestamp: new Date().toISOString(),
+            filename,
+            description,
+            step: ++DeviceFarmViewer.stepCounter,
+            base64: DeviceFarmViewer.loadScreenshotAsDataUri(filename),
+        };
+        DeviceFarmViewer.session.screenshots.push(screenshot);
+        DeviceFarmViewer.saveSessionData();
+    }
+    /**
+     * 🚀 Inicia o viewer integrado
+     */
+    static async start(deviceId = 'unknown') {
+        try {
+            // Configurar projeto consumidor
+            await DeviceFarmViewer.setupConsumerProject();
+            DeviceFarmViewer.isActive = true;
+            DeviceFarmViewer.stepCounter = 0;
+            // Criar diretórios necessários
+            DeviceFarmViewer.ensureDirectories();
+            // Inicializar sessão
+            DeviceFarmViewer.session = {
+                deviceId,
+                startTime: new Date().toISOString(),
+                status: 'WAITING',
+                screenshots: [],
+                stepCount: 0,
+                lastUpdate: new Date().toISOString(),
+                consumerProject: DeviceFarmViewer.consumerProjectPath
+                    ? basename(DeviceFarmViewer.consumerProjectPath)
+                    : undefined,
+                deviceFarmUrl: `https://devicefarm-qa.com.br/#/watcher?device=${deviceId}`,
+            };
+            // Salvar dados iniciais
+            await DeviceFarmViewer.saveSessionData();
+            // Gerar HTML integrado
+            const htmlPath = await DeviceFarmViewer.generateIntegratedHtml();
+            // ✅ ABERTURA AUTOMÁTICA DO HTML (controlada por variável de ambiente)
+            // Abre APENAS se MOBILE_UI_MODE=true (comandos ui:*) OU se DISABLE_DEVICEFARM_AUTOOPEN não está definido como true
+            const isUiMode = process.env.MOBILE_UI_MODE === 'true';
+            const autoOpenDisabled = process.env.DISABLE_DEVICEFARM_AUTOOPEN === 'true';
+            const shouldAutoOpen = isUiMode && !autoOpenDisabled;
+            if (shouldAutoOpen) {
+                try {
+                    const absoluteHtmlPath = resolve(htmlPath);
+                    const fileUrl = `file:///${absoluteHtmlPath.replace(/\\/g, '/')}`;
+                    // Tentar abrir no navegador padrão do sistema
+                    if (process.platform === 'win32') {
+                        execSync(`start "" "${fileUrl}"`);
+                    }
+                    else if (process.platform === 'darwin') {
+                        execSync(`open "${fileUrl}"`);
+                    }
+                    else {
+                        execSync(`xdg-open "${fileUrl}"`);
+                    }
+                    console.log(`🌐 HTML aberto automaticamente no navegador: ${fileUrl}`);
+                }
+                catch (openError) {
+                    SimpleLogger.warning(`Não foi possível abrir automaticamente o HTML: ${String(openError)}`);
+                    console.log(`📋 Abra manualmente: ${resolve(htmlPath)}`);
+                }
+            }
+            else {
+                SimpleLogger.info(`📋 Auto-abertura desabilitada. Arquivo disponível em: ${resolve(htmlPath)}`);
+            }
+            console.log(`🎥 DeviceFarm Viewer iniciado: ${htmlPath}`);
+            return htmlPath;
+        }
+        catch (error) {
+            SimpleLogger.error(`❌ Erro ao iniciar DeviceFarm Viewer: ${String(error)}`);
+            throw error;
+        }
+    }
+    /**
+     * 🎨 Gera HTML integrado com DeviceFarm com dados embutidos (SEM SERVIDOR)
+     */
+    static generateIntegratedHtml() {
+        const htmlPath = join('./test-results/mobile-viewer', 'devicefarm-integrated-viewer.html');
+        const deviceId = DeviceFarmViewer.session?.deviceId || 'unknown';
+        DeviceFarmViewer.ensureBase64ForScreenshots();
+        // ✅ HTML COMPLETAMENTE OFFLINE - Dados embutidos no JavaScript
+        const htmlContent = [
+            '<!DOCTYPE html>',
+            '<html lang="pt-BR">',
+            '<head>',
+            '    <meta charset="UTF-8">',
+            '    <meta name="viewport" content="width=device-width, initial-scale=1.0">',
+            '    <title>📱 DeviceFarm Live Viewer - AUTO REFRESH</title>',
+            '    <script src="https://cdn.tailwindcss.com"></script>',
+            '    <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 src="https://cdn.jsdelivr.net/npm/xlsx@0.18.5/dist/xlsx.full.min.js"></script>',
+            '    <style>',
+            '        @keyframes pulse-live { 0%, 100% { opacity: 1; transform: scale(1); } 50% { opacity: 0.7; transform: scale(1.05); } }',
+            '        .live-pulse { animation: pulse-live 1.5s infinite; }',
+            '        body { font-family: "Inter", "Segoe UI", sans-serif; transition: all 0.3s ease; }',
+            '        .light-mode { background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 50%, #cbd5e1 100%) !important; color: #1e293b !important; }',
+            '        .light-mode .text-white { color: #1e293b !important; }',
+            '        .light-mode .text-slate-200 { color: #475569 !important; }',
+            '        .light-mode .text-slate-300 { color: #64748b !important; }',
+            '        .light-mode .text-slate-400 { color: #94a3b8 !important; }',
+            '        .light-mode .text-yellow-400 { color: #d97706 !important; }',
+            '        .light-mode .bg-slate-900\\/50 { background: rgba(248, 250, 252, 0.9) !important; border-color: rgba(203, 213, 225, 0.5) !important; }',
+            '        .light-mode .bg-slate-800\\/60 { background: rgba(241, 245, 249, 0.8) !important; border-color: rgba(203, 213, 225, 0.6) !important; }',
+            '        .light-mode .bg-slate-800\\/40 { background: rgba(248, 250, 252, 0.7) !important; border-color: rgba(203, 213, 225, 0.5) !important; }',
+            '        .light-mode .bg-slate-900\\/30 { background: rgba(241, 245, 249, 0.6) !important; border-color: rgba(203, 213, 225, 0.5) !important; }',
+            '        .light-mode .bg-slate-700\\/30 { background: rgba(226, 232, 240, 0.7) !important; border-color: rgba(203, 213, 225, 0.6) !important; }',
+            '        .light-mode .border-slate-700\\/50 { border-color: rgba(203, 213, 225, 0.5) !important; }',
+            '        .light-mode .border-slate-600\\/50 { border-color: rgba(203, 213, 225, 0.6) !important; }',
+            '        .light-mode .border-slate-600\\/30 { border-color: rgba(203, 213, 225, 0.4) !important; }',
+            '        .btn-export { transition: all 0.2s ease; }',
+            '        .btn-export:hover { transform: translateY(-1px); }',
+            '    </style>',
+            '</head>',
+            '<body id="viewer-root" class="bg-gradient-to-br from-slate-900 via-slate-800 to-slate-700 text-white min-h-screen transition-all duration-300">',
+            '    <!-- Header com estilo moderno -->',
+            '    <div class="bg-slate-900/50 backdrop-blur-sm border-b border-slate-700/50 px-8 py-4">',
+            '        <div class="flex justify-between items-center">',
+            '            <h1 class="text-2xl font-bold text-yellow-400 flex items-center gap-2">',
+            '                📱 <span>DeviceFarm Live Viewer</span>',
+            '            </h1>',
+            '            <div class="flex gap-4 text-sm">',
+            '                <div class="bg-slate-800/60 px-4 py-2 rounded-lg border border-slate-600/50">',
+            '                    <span class="text-slate-300">Device:</span> ',
+            '                    <span id="device-id" class="text-white font-semibold">' +
+                deviceId +
+                '</span>',
+            '                </div>',
+            '                <div class="bg-slate-800/60 px-4 py-2 rounded-lg border border-slate-600/50">',
+            '                    <span class="text-slate-300">Screenshots:</span> ',
+            '                    <span id="screenshot-count" class="text-emerald-400 font-bold">0</span>',
+            '                </div>',
+            '                <div class="bg-slate-800/60 px-4 py-2 rounded-lg border border-slate-600/50">',
+            '                    <span class="text-slate-300">Status:</span> ',
+            '                    <span id="session-status" class="text-blue-400 font-semibold">LOADING</span>',
+            '                </div>',
+            '                <div class="bg-green-500/20 border border-green-500/30 px-4 py-2 rounded-lg live-pulse flex items-center gap-2">',
+            '                    <span class="text-green-400 font-bold">🔄 AUTO-REFRESH:</span>',
+            '                    <select id="refresh-interval" class="bg-slate-700 text-white px-3 py-1 rounded border border-slate-500 font-semibold cursor-pointer">',
+            '                        <option value="1">1s</option>',
+            '                        <option value="5">5s</option>',
+            '                        <option value="10">10s</option>',
+            '                        <option value="20" selected>20s</option>',
+            '                        <option value="30">30s</option>',
+            '                        <option value="60">1min</option>',
+            '                    </select>',
+            '                    <span id="countdown" class="text-yellow-400 font-mono text-sm">20s</span>',
+            '                </div>',
+            '            </div>',
+            '        </div>',
+            '    </div>',
+            '',
+            '    <!-- Barra de controles e exportação -->',
+            '    <div class="bg-slate-800/30 border-b border-slate-700/30 px-8 py-3">',
+            '        <div class="flex gap-2 justify-end">',
+            '            <button id="toggle-theme" class="bg-slate-700 hover:bg-slate-600 text-white px-4 py-2 rounded-lg font-medium transition-all duration-200 btn-export flex items-center gap-2" title="Alternar tema">',
+            '                🌙 <span>Tema</span>',
+            '            </button>',
+            '            <button id="export-pdf" class="bg-red-600 hover:bg-red-700 text-white px-4 py-2 rounded-lg font-medium transition-all duration-200 btn-export flex items-center gap-2" title="Exportar PDF">',
+            '                📄 <span>PDF</span>',
+            '            </button>',
+            '            <button id="export-json" class="bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded-lg font-medium transition-all duration-200 btn-export flex items-center gap-2" title="Exportar JSON">',
+            '                🗒️ <span>JSON</span>',
+            '            </button>',
+            '            <button id="export-xlsx" class="bg-green-600 hover:bg-green-700 text-white px-4 py-2 rounded-lg font-medium transition-all duration-200 btn-export flex items-center gap-2" title="Exportar XLSX">',
+            '                📊 <span>XLSX</span>',
+            '            </button>',
+            '        </div>',
+            '    </div>',
+            '',
+            '    <!-- Conteúdo principal -->',
+            '    <div class="flex h-[calc(100vh-140px)]">',
+            '        <!-- Painel esquerdo - Screenshot principal -->',
+            '        <div class="flex-1 lg:flex-[2] p-6">',
+            '            <div class="bg-slate-800/40 backdrop-blur-sm border border-slate-700/50 rounded-2xl p-6 h-full shadow-2xl">',
+            '                <!-- Container de aguardo -->',
+            '                <div id="waiting-container" class="flex flex-col items-center justify-center h-full text-center">',
+            '                    <div class="bg-slate-700/30 p-8 rounded-xl border border-slate-600/30 shadow-lg">',
+            '                        <div class="text-6xl mb-4">⏳</div>',
+            '                        <h3 class="text-xl font-semibold text-slate-200 mb-2">Aguardando screenshots...</h3>',
+            '                        <p class="text-slate-400">🔄 Atualizando automaticamente</p>',
+            '                    </div>',
+            '                </div>',
+            '',
+            '                <!-- Container do screenshot -->',
+            '                <div id="screenshot-container" class="flex flex-col items-center justify-center h-full" style="display: none;">',
+            '                    <div class="bg-slate-900/50 p-4 rounded-xl border border-slate-600/30 max-w-full max-h-full shadow-xl">',
+            '                        <img id="current-screenshot" src="" alt="Screenshot atual" ',
+            '                             class="max-w-full max-h-[70vh] rounded-lg shadow-2xl border border-slate-600/30">',
+            '                        <div id="screenshot-info" class="mt-4 text-center">',
+            '                            <div id="screenshot-description" class="text-lg font-medium text-slate-200 mb-1">-</div>',
+            '                            <div id="screenshot-timestamp" class="text-sm text-slate-400">-</div>',
+            '                        </div>',
+            '                    </div>',
+            '                </div>',
+            '            </div>',
+            '',
+            '            <!-- Botões de ação -->',
+            '            <div class="flex gap-3 mt-4">',
+            '                <button onclick="openDeviceFarm()" ',
+            '                        class="bg-blue-600 hover:bg-blue-700 text-white px-6 py-3 rounded-xl font-semibold transition-all duration-200 flex items-center gap-2 shadow-lg hover:shadow-xl hover:scale-105">',
+            '                    🌐 Abrir DeviceFarm',
+            '                </button>',
+            '                <button onclick="refreshData()" ',
+            '                        class="bg-emerald-600 hover:bg-emerald-700 text-white px-6 py-3 rounded-xl font-semibold transition-all duration-200 flex items-center gap-2 shadow-lg hover:shadow-xl hover:scale-105">',
+            '                    🔄 Recarregar',
+            '                </button>',
+            '            </div>',
+            '        </div>',
+            '        <!-- Painel direito - Lista de screenshots -->',
+            '        <div class="w-full lg:w-80 xl:w-96 p-6 bg-slate-900/30 backdrop-blur-sm border-l border-slate-700/50 overflow-y-auto">',
+            '            <h3 class="text-xl font-bold text-yellow-400 mb-4 flex items-center gap-2">',
+            '                📸 <span>Screenshots em Tempo Real</span>',
+            '            </h3>',
+            '',
+            '            <!-- Info box -->',
+            '            <div class="bg-slate-800/60 border border-slate-600/40 rounded-xl p-4 mb-6">',
+            '                <div class="text-green-400 font-semibold mb-2 flex items-center gap-2">',
+            '                    ✅ <span>Auto-Refresh Ativo</span>',
+            '                </div>',
+            '                <div class="text-sm text-slate-300 space-y-1">',
+            '                    <div>📱 Página atualiza automaticamente a cada 3 segundos</div>',
+            '                    <div>📸 Screenshots aparecem conforme o teste executa</div>',
+            '                </div>',
+            '            </div>',
+            '',
+            '            <!-- Lista de screenshots -->',
+            '            <div id="screenshots-list" class="space-y-3">',
+            '                <div class="text-slate-400 text-center py-8">',
+            '                    📷 Screenshots aparecerão aqui conforme o teste executa',
+            '                </div>',
+            '            </div>',
+            '        </div>',
+            '    </div>',
+            '',
+            '    <script>',
+            '        // ✅ DADOS EMBUTIDOS - Atualizados dinamicamente',
+            '        let sessionData = ' +
+                JSON.stringify(DeviceFarmViewer.session || {
+                    deviceId,
+                    startTime: new Date().toISOString(),
+                    status: 'WAITING',
+                    screenshots: [],
+                    stepCount: 0,
+                    lastUpdate: new Date().toISOString(),
+                }, null, 8) +
+                ';',
+            '',
+            '        // ⏱️ CONTROLE DE AUTO-REFRESH',
+            '        let refreshInterval = 20; // segundos (padrão)',
+            '        let countdownSeconds = refreshInterval;',
+            '        let countdownTimer = null;',
+            '        let refreshTimer = null;',
+            '',
+            '        function startAutoRefresh() {',
+            '            // Limpar timers existentes',
+            '            if (countdownTimer) clearInterval(countdownTimer);',
+            '            if (refreshTimer) clearTimeout(refreshTimer);',
+            '            ',
+            '            // Resetar countdown',
+            '            countdownSeconds = refreshInterval;',
+            '            updateCountdown();',
+            '            ',
+            '            // Countdown visual',
+            '            countdownTimer = setInterval(() => {',
+            '                countdownSeconds--;',
+            '                updateCountdown();',
+            '                ',
+            '                if (countdownSeconds <= 0) {',
+            '                    clearInterval(countdownTimer);',
+            '                }',
+            '            }, 1000);',
+            '            ',
+            '            // Timer de refresh',
+            '            refreshTimer = setTimeout(() => {',
+            '                location.reload();',
+            '            }, refreshInterval * 1000);',
+            '        }',
+            '',
+            '        function updateCountdown() {',
+            '            const countdownEl = document.getElementById("countdown");',
+            '            if (countdownEl) {',
+            '                if (countdownSeconds >= 60) {',
+            '                    countdownEl.textContent = Math.floor(countdownSeconds / 60) + "min " + (countdownSeconds % 60) + "s";',
+            '                } else {',
+            '                    countdownEl.textContent = countdownSeconds + "s";',
+            '                }',
+            '            }',
+            '        }',
+            '',
+            '        function updateUI() {',
+            '            if (!sessionData) return;',
+            '            ',
+            '            document.getElementById("device-id").textContent = sessionData.deviceId || "' +
+                deviceId +
+                '";',
+            '            document.getElementById("screenshot-count").textContent = sessionData.screenshots ? sessionData.screenshots.length : 0;',
+            '            document.getElementById("session-status").textContent = sessionData.status || "WAITING";',
+            '            ',
+            '            updateScreenshots();',
+            '            ',
+            '            // 🆕 SEMPRE MOSTRAR SCREENSHOT (se houver)',
+            '            const screenshotContainer = document.getElementById("screenshot-container");',
+            '            const waitingContainer = document.getElementById("waiting-container");',
+            '            ',
+            '            if (sessionData.screenshots && sessionData.screenshots.length > 0) {',
+            '                if (waitingContainer) waitingContainer.style.display = "none";',
+            '                if (screenshotContainer) screenshotContainer.style.display = "flex";',
+            '                showLatestScreenshot();',
+            '            } else {',
+            '                if (waitingContainer) waitingContainer.style.display = "flex";',
+            '                if (screenshotContainer) screenshotContainer.style.display = "none";',
+            '            }',
+            '        }',
+            '',
+            '        function updateScreenshots() {',
+            '            const screenshotsList = document.getElementById("screenshots-list");',
+            '            ',
+            '            if (!sessionData.screenshots || sessionData.screenshots.length === 0) {',
+            '                screenshotsList.innerHTML = "<div class=\\"text-slate-400 text-center py-8\\">📷 Screenshots aparecerão aqui conforme o teste executa</div>";',
+            '                return;',
+            '            }',
+            '            ',
+            '            const screenshots = sessionData.screenshots.slice().reverse();',
+            '            let html = "";',
+            '            for (let i = 0; i < screenshots.length; i++) {',
+            '                const s = screenshots[i];',
+            '                html += "<div class=\\"bg-slate-800/40 border border-slate-600/30 rounded-xl p-4 cursor-pointer transition-all duration-200 hover:bg-slate-700/50 hover:border-slate-500/50 hover:shadow-lg\\" onclick=\\"showScreenshot(\'" + s.filename + "\', \'" + s.description + "\', \'" + s.timestamp + "\')\\">";',
+            '                html += "<div class=\\"text-slate-200 font-medium mb-1\\"><span class=\\"text-yellow-400 font-semibold\\">Step " + s.step + ":</span> " + s.description + "</div>";',
+            '                html += "<div class=\\"text-xs text-slate-400\\">" + formatTime(s.timestamp) + "</div>";',
+            '                html += "</div>";',
+            '            }',
+            '            screenshotsList.innerHTML = html;',
+            '        }',
+            '',
+            '        function showLatestScreenshot() {',
+            '            if (sessionData.screenshots && sessionData.screenshots.length > 0) {',
+            '                const latest = sessionData.screenshots[sessionData.screenshots.length - 1];',
+            '                showScreenshot(latest.filename, latest.description, latest.timestamp);',
+            '            }',
+            '        }',
+            '',
+            '        function showScreenshot(filename, description, timestamp) {',
+            '            const container = document.getElementById("screenshot-container");',
+            '            const img = document.getElementById("current-screenshot");',
+            '            const desc = document.getElementById("screenshot-description");',
+            '            const time = document.getElementById("screenshot-timestamp");',
+            '            ',
+            '            const screenshotItem = sessionData && sessionData.screenshots ? sessionData.screenshots.find(s => s.filename === filename) : null;',
+            '            const base64Data = screenshotItem && screenshotItem.base64 ? screenshotItem.base64 : null;',
+            '            const screenshotPath = base64Data || "./screenshots/" + filename;',
+            '            ',
+            '            img.onload = function() {',
+            '                container.style.display = "block";',
+            '                desc.textContent = description;',
+            '                time.textContent = formatTime(timestamp);',
+            '                console.log("📸 Screenshot carregado:", screenshotPath);',
+            '            };',
+            '            ',
+            '            img.onerror = function() {',
+            '                if (base64Data) {',
+            '                    return;',
+            '                }',
+            '                console.log("⚠️ Screenshot não encontrado:", screenshotPath);',
+            '                const altPath = "../mobile-screenshots/" + filename;',
+            '                img.src = altPath;',
+            '                img.onerror = function() {',
+            '                    console.log("⚠️ Screenshot alternativo não encontrado:", altPath);',
+            '                    desc.textContent = "⚠️ " + description + " (imagem não encontrada)";',
+            '                    time.textContent = formatTime(timestamp);',
+            '                    container.style.display = "block";',
+            '                };',
+            '            };',
+            '            ',
+            '            img.src = screenshotPath;',
+            '        }',
+            '',
+            '        function formatTime(timestamp) {',
+            '            try {',
+            '                return new Date(timestamp).toLocaleString("pt-BR");',
+            '            } catch {',
+            '                return timestamp;',
+            '            }',
+            '        }',
+            '',
+            '        function openDeviceFarm() {',
+            '            if (sessionData && sessionData.deviceFarmUrl) {',
+            '                window.open(sessionData.deviceFarmUrl, "_blank");',
+            '            } else {',
+            '                window.open("https://devicefarm-qa.com.br/#/watcher?device=' +
+                deviceId +
+                '", "_blank");',
+            '            }',
+            '        }',
+            '',
+            '        function refreshData() {',
+            '            location.reload();',
+            '        }',
+            '',
+            '        // 🎨 MODO CLARO/ESCURO',
+            '        function toggleTheme() {',
+            '            const root = document.getElementById("viewer-root");',
+            '            root.classList.toggle("light-mode");',
+            '            ',
+            '            // Atualizar classes TailwindCSS para modo claro',
+            '            if (root.classList.contains("light-mode")) {',
+            '                root.className = root.className.replace("bg-gradient-to-br from-slate-900 via-slate-800 to-slate-700", "bg-gradient-to-br from-gray-50 via-gray-100 to-gray-200");',
+            '            } else {',
+            '                root.className = root.className.replace("bg-gradient-to-br from-gray-50 via-gray-100 to-gray-200", "bg-gradient-to-br from-slate-900 via-slate-800 to-slate-700");',
+            '            }',
+            '        }',
+            '',
+            '        // 📊 FUNÇÕES DE EXPORTAÇÃO',
+            '        function getSessionData() {',
+            '            return {',
+            '                deviceId: sessionData.deviceId,',
+            '                status: sessionData.status,',
+            '                startTime: sessionData.startTime,',
+            '                endTime: sessionData.endTime,',
+            '                screenshots: sessionData.screenshots,',
+            '                stepCount: sessionData.stepCount,',
+            '                lastUpdate: sessionData.lastUpdate,',
+            '                exportDate: new Date().toISOString()',
+            '            };',
+            '        }',
+            '',
+            '        async function exportToPDF() {',
+            '            console.log("🔵 [PDF] Botão clicado - Iniciando geração do PDF do DeviceFarm...");',
+            '            ',
+            '            const element = document.getElementById("viewer-root");',
+            '            if (!element) {',
+            '                console.error("❌ [PDF] Elemento viewer-root não encontrado!");',
+            '                alert("❌ Erro: Elemento do relatório não encontrado!");',
+            '                return;',
+            '            }',
+            '            ',
+            '            const hasImages = element.querySelectorAll("img").length > 0;',
+            '            if (hasImages) {',
+            '                console.log("📸 [PDF] Imagens detectadas - preparando incorporação para ambiente offline");',
+            '            }',
+            '            ',
+            '            const originalBg = element.style.background;',
+            '            const originalColor = element.style.color;',
+            '            ',
+            '            // 🆕 Mostrar container de screenshot se houver screenshots',
+            '            const screenshotContainer = document.getElementById("screenshot-container");',
+            '            const waitingContainer = document.getElementById("waiting-container");',
+            '            const originalScreenshotDisplay = screenshotContainer ? screenshotContainer.style.display : "";',
+            '            const originalWaitingDisplay = waitingContainer ? waitingContainer.style.display : "";',
+            '            ',
+            '            if (sessionData && sessionData.screenshots && sessionData.screenshots.length > 0) {',
+            '                if (screenshotContainer) screenshotContainer.style.display = "block";',
+            '                if (waitingContainer) waitingContainer.style.display = "none";',
+            '                ',
+            '                // Carregar screenshot mais recente',
+            '                const latest = sessionData.screenshots[sessionData.screenshots.length - 1];',
+            '                showScreenshot(latest.filename, latest.description, latest.timestamp);',
+            '            }',
+            '            ',
+            '            // Aguardar imagens carregarem',
+            '            const images = element.querySelectorAll("img");',
+            '            console.log("📸 Total de imagens encontradas:", images.length);',
+            '            ',
+            '            await Promise.all(Array.from(images).map(img => {',
+            '                if (img.complete) return Promise.resolve();',
+            '                return new Promise(resolve => {',
+            '                    img.onload = resolve;',
+            '                    img.onerror = resolve;',
+            '                    setTimeout(resolve, 2000);',
+            '                });',
+            '            }));',
+            '            ',
+            '            console.log("✅ Imagens aguardadas");',
+            '            await new Promise(resolve => setTimeout(resolve, 500));',
+            '            ',
+            '            // Configurar para PDF',
+            '            element.style.background = "#fff";',
+            '            element.style.color = "#222";',
+            '            ',
+            '            // Verificar se jsPDF está disponível',
+            '            if (typeof jspdf === "undefined") {',
+            '                console.error("❌ jsPDF não está carregado!");',
+            '                alert("❌ Erro: Biblioteca jsPDF não carregada. Recarregue a página e tente novamente.");',
+            '                // Restaurar estilos',
+            '                element.style.background = originalBg;',
+            '                element.style.color = originalColor;',
+            '                if (screenshotContainer) screenshotContainer.style.display = originalScreenshotDisplay;',
+            '                if (waitingContainer) waitingContainer.style.display = originalWaitingDisplay;',
+            '                return;',
+            '            }',
+            '            ',
+            '            console.log("📄 Iniciando geração do PDF...");',
+            '            ',
+            '            try {',
+            '                // Usar html2canvas para capturar o conteúdo como imagem',
+            '                const canvas = await html2canvas(element, {',
+            '                    scale: 2,',
+            '                    useCORS: false,',
+            '                    allowTaint: true,',
+            '                    backgroundColor: "#fff",',
+            '                    logging: false,',
+            '                    imageTimeout: 0',
+            '                });',
+            '                ',
+            '                // 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; // A4 width in mm',
+            '                const pageHeight = 297; // A4 height in mm',
+            '                const imgHeight = (canvas.height * imgWidth) / canvas.width;',
+            '                let heightLeft = imgHeight;',
+            '                let position = 0;',
+            '                ',
+            '                // Adicionar primeira página',
+            '                pdf.addImage(imgData, "JPEG", 0, position, imgWidth, imgHeight);',
+            '                heightLeft -= pageHeight;',
+            '                ',
+            '                // Adicionar páginas extras se necessário',
+            '                while (heightLeft > 0) {',
+            '                    position = heightLeft - imgHeight;',
+            '                    pdf.addPage();',
+            '                    pdf.addImage(imgData, "JPEG", 0, position, imgWidth, imgHeight);',
+            '                    heightLeft -= pageHeight;',
+            '                }',
+            '                ',
+            '                // Salvar PDF',
+            '                pdf.save(`devicefarm-viewer-${sessionData.deviceId}-${new Date().toISOString().split("T")[0]}.pdf`);',
+            '                ',
+            '                console.log("✅ PDF gerado com sucesso!");',
+            '                alert("✅ PDF gerado com sucesso! Verifique sua pasta de Downloads.");',
+            '            } catch (error) {',
+            '                console.error("❌ Erro ao gerar PDF:", error);',
+            '                alert("❌ Erro ao gerar PDF: " + (error.message || error));',
+            '            } finally {',
+            '                // Restaurar estilos',
+            '                element.style.background = originalBg;',
+            '                element.style.color = originalColor;',
+            '                if (screenshotContainer) screenshotContainer.style.display = originalScreenshotDisplay;',
+            '                if (waitingContainer) waitingContainer.style.display = originalWaitingDisplay;',
+            '            }',
+            '        }',
+            '',
+            '        function exportToJSON() {',
+            '            const data = getSessionData();',
+            '            const blob = new Blob([JSON.stringify(data, null, 2)], { type: "application/json" });',
+            '            const url = URL.createObjectURL(blob);',
+            '            const a = document.createElement("a");',
+            '            a.href = url;',
+            '            a.download = `devicefarm-session-${sessionData.deviceId}-${new Date().toISOString().split("T")[0]}.json`;',
+            '            a.click();',
+            '            URL.revokeObjectURL(url);',
+            '        }',
+            '',
+            '        function exportToXLSX() {',
+            '            const screenshots = sessionData.screenshots || [];',
+            '            const data = screenshots.map(s => ({',
+            '                "Step": s.step,',
+            '                "Descrição": s.description,',
+            '                "Arquivo": s.filename,',
+            '                "Timestamp": formatTime(s.timestamp)',
+            '            }));',
+            '            ',
+            '            // Adicionar informações da sessão',
+            '            const sessionInfo = [{',
+            '                "Step": "INFO",',
+            '                "Descrição": `Device: ${sessionData.deviceId}`,',
+            '                "Arquivo": `Status: ${sessionData.status}`,',
+            '                "Timestamp": `Total Screenshots: ${screenshots.length}`',
+            '            }];',
+            '            ',
+            '            const allData = [...sessionInfo, ...data];',
+            '            const ws = XLSX.utils.json_to_sheet(allData);',
+            '            const wb = XLSX.utils.book_new();',
+            '            XLSX.utils.book_append_sheet(wb, ws, "DeviceFarm Session");',
+            '            XLSX.writeFile(wb, `devicefarm-session-${sessionData.deviceId}-${new Date().toISOString().split("T")[0]}.xlsx`);',
+            '        }',
+            '',
+            '        // 🎯 EVENT LISTENERS',
+            '        document.getElementById("toggle-theme").onclick = toggleTheme;',
+            '        document.getElementById("export-pdf").onclick = exportToPDF;',
+            '        document.getElementById("export-json").onclick = exportToJSON;',
+            '        document.getElementById("export-xlsx").onclick = exportToXLSX;',
+            '',
+            '        // 🆕 Listener para mudança no intervalo de refresh',
+            '        document.getElementById("refresh-interval").onchange = function(e) {',
+            '            refreshInterval = parseInt(e.target.value);',
+            '            console.log("🔄 Intervalo de refresh alterado para:", refreshInterval, "segundos");',
+            '            startAutoRefresh(); // Reiniciar com novo intervalo',
+            '        };',
+            '',
+            '        // ✅ AUTO-INICIALIZAR',
+            '        document.addEventListener("DOMContentLoaded", function() {',
+            '            updateUI();',
+            '            startAutoRefresh(); // Iniciar auto-refresh',
+            '            console.log("📱 DeviceFarm Viewer inicializado em modo offline");',
+            '            console.log("🔄 Auto-refresh configurado para", refreshInterval, "segundos");',
+            '        });',
+            '    </script>',
+            '</body>',
+            '</html>',
+        ].join('\n');
+        // Salvar arquivo HTML
+        writeFileSync(htmlPath, htmlContent, 'utf8');
+        return htmlPath;
+    }
+    /**
+     * 📄 JavaScript para polling e atualização dinâmica
+     */
+    static getViewerJavaScript(deviceId) {
+        return [
+            '    <script>',
+            '        let sessionData = null;',
+            '        let lastUpdateTime = 0;',
+            '        let refreshInterval = null;',
+            '        let testFinished = false;',
+            '        let noActivityCount = 0;',
+            '        let currentPollingInterval = 3000; // Inicia com 3 segundos',
+            '        ',
+            '        function startDataPolling() {',
+            '            refreshInterval = setInterval(loadSessionData, currentPollingInterval);',
+            '            loadSessionData();',
+            '        }',
+            '        ',
+            '        function adjustPollingRate() {',
+            '            if (testFinished) {',
+            '                console.log("🏁 Teste finalizado - parando polling");',
+            '                if (refreshInterval) {',
+            '                    clearInterval(refreshInterval);',
+            '                    refreshInterval = null;',
+            '                }',
+            '                return;',
+            '            }',
+            '            ',
+            '            // Se não houve atividade por muito tempo, aumentar intervalo',
+            '            if (noActivityCount > 5) {',
+            '                if (currentPollingInterval < 10000) {',
+            '                    currentPollingInterval = 10000; // 10 segundos',
+            '                    console.log("⏱️ Reduzindo frequência de polling para 10s (sem atividade)");',
+            '                    // Recriar intervalo com nova frequência',
+            '                    if (refreshInterval) {',
+            '                        clearInterval(refreshInterval);',
+            '                    }',
+            '                    refreshInterval = setInterval(loadSessionData, currentPollingInterval);',
+            '                }',
+            '            }',
+            '        }',
+            '        ',
+            '        async function loadSessionData() {',
+            '            try {',
+            '                const response = await fetch("./session-data.json?t=" + Date.now());',
+            '                if (response.ok) {',
+            '                    const data = await response.json();',
+            '                    if (data && data.lastUpdate !== lastUpdateTime) {',
+            '                        sessionData = data;',
+            '                        lastUpdateTime = data.lastUpdate;',
+            '                        noActivityCount = 0; // Reset contador',
+            '                        ',
+            '                        // Verificar se o teste terminou',
+            '                        if (data.status === "FINISHED") {',
+            '                            testFinished = true;',
+            '                            console.log("🏁 Status FINISHED detectado");',
+            '                        }',
+            '                        ',
+            '                        updateUI();',
+            '                        console.log("📊 Dados atualizados:", data);',
+            '                    } else {',
+            '                        noActivityCount++;',
+            '                        adjustPollingRate();',
+            '                    }',
+            '                } else {',
+            '                    console.log("📊 Aguardando dados da sessão...");',
+            '                    noActivityCount++;',
+            '                    adjustPollingRate();',
+            '                }',
+            '            } catch (error) {',
+            '                console.log("⚠️ Erro ao carregar dados:", error);',
+            '                noActivityCount++;',
+            '                adjustPollingRate();',
+            '            }',
+            '        }',
+            '        ',
+            '        function updateUI() {',
+            '            if (!sessionData) return;',
+            '            ',
+            '            document.getElementById("device-id").textContent = sessionData.deviceId || "' +
+                deviceId +
+                '";',
+            '            document.getElementById("screenshot-count").textContent = sessionData.screenshots ? sessionData.screenshots.length : 0;',
+            '            document.getElementById("session-status").textContent = sessionData.status || "UNKNOWN";',
+            '            ',
+            '            updateScreenshots();',
+            '            ',
+            '            if (sessionData.screenshots && sessionData.screenshots.length > 0) {',
+            '                document.getElementById("waiting-container").style.display = "none";',
+            '                showLatestScreenshot();',
+            '            }',
+            '        }',
+            '        ',
+            '        function updateScreenshots() {',
+            '            const screenshotsList = document.getElementById("screenshots-list");',
+            '            ',
+            '            if (!sessionData.screenshots || sessionData.screenshots.length === 0) {',
+            '                screenshotsList.innerHTML = "<p style=\\"opacity: 0.7;\\">📷 Screenshots aparecerão aqui conforme o teste executa</p>";',
+            '                return;',
+            '            }',
+            '            ',
+            '            const screenshots = sessionData.screenshots.slice().reverse();',
+            '            let html = "";',
+            '            for (let i = 0; i < screenshots.length; i++) {',
+            '                const s = screenshots[i];',
+            '                html += "<div class=\\"screenshot-item\\" onclick=\\"showScreenshot(\'" + s.filename + "\', \'" + s.description + "\', \'" + s.timestamp + "\')\\">";',
+            '                html += "<div><strong>Step " + s.step + ":</strong> " + s.description + "</div>";',
+            '                html += "<div style=\\"font-size: 0.8em; opacity: 0.7;\\">" + formatTime(s.timestamp) + "</div>";',
+            '                html += "</div>";',
+            '            }',
+            '            screenshotsList.innerHTML = html;',
+            '        }',
+            '        ',
+            '        function showLatestScreenshot() {',
+            '            if (sessionData.screenshots && sessionData.screenshots.length > 0) {',
+            '                const latest = sessionData.screenshots[sessionData.screenshots.length - 1];',
+            '                showScreenshot(latest.filename, latest.description, latest.timestamp);',
+            '            }',
+            '        }',
+            '        ',
+            '        function showScreenshot(filename, description, timestamp) {',
+            '            const container = document.getElementById("screenshot-container");',
+            '            const img = document.getElementById("current-screenshot");',
+            '            const desc = document.getElementById("screenshot-description");',
+            '            const time = document.getElementById("screenshot-timestamp");',
+            '            ',
+            '            const screenshotItem = sessionData && sessionData.screenshots ? sessionData.screenshots.find(s => s.filename === filename) : null;',
+            '            const base64Data = screenshotItem && screenshotItem.base64 ? screenshotItem.base64 : null;',
+            '            const screenshotPath = base64Data || "./screenshots/" + filename;',
+            '            ',
+            '            img.onload = function() {',
+            '                container.style.display = "block";',
+            '                desc.textContent = description;',
+            '                time.textContent = formatTime(timestamp);',
+            '                console.log("📸 Screenshot carregado:", screenshotPath);',
+            '            };',
+            '            ',
+            '            img.onerror = function() {',
+            '                if (base64Data) {',
+            '                    return;',
+            '                }',
+            '                console.log("⚠️ Screenshot não encontrado:", screenshotPath);',
+            '                const altPath = "../mobile-screenshots/" + filename;',
+            '                img.src = altPath;',
+            '                img.onerror = function() {',
+            '                    console.log("⚠️ Screenshot alternativo não encontrado:", altPath);',
+            '                    desc.textContent = "⚠️ " + description + " (imagem não encontrada)";',
+            '                    time.textContent = formatTime(timestamp);',
+            '                    container.style.display = "block";',
+            '                };',
+            '            };',
+            '            ',
+            '            img.src = screenshotPath;',
+            '        }',
+            '        ',
+            '        function formatTime(timestamp) {',
+            '            try {',
+            '                return new Date(timestamp).toLocaleString("pt-BR");',
+            '            } catch {',
+            '                return timestamp;',
+            '            }',
+            '        }',
+            '        ',
+            '        function openDeviceFarm() {',
+            '            if (sessionData && sessionData.deviceFarmUrl) {',
+            '                window.open(sessionData.deviceFarmUrl, "_blank");',
+            '            } else {',
+            '                window.open("https://devicefarm-qa.com.br/#/watcher?device=' +
+                deviceId +
+                '", "_blank");',
+            '            }',
+            '        }',
+            '        ',
+            '        function refreshData() {',
+            '            loadSessionData();',
+            '        }',
+            '        ',
+            '        window.onload = function() {',
+            '            console.log("🎥 DeviceFarm Viewer carregado - iniciando polling...");',
+            '            startDataPolling();',
+            '        };',
+            '        ',
+            '        window.onbeforeunload = function() {',
+            '            if (refreshInterval) {',
+            '                clearInterval(refreshInterval);',
+            '            }',
+            '        };',
+            '    </script>',
+        ].join('\n');
+    }
+    /**
+     * 📸 Adiciona screenshot (chamado automaticamente por MobileActions)
+     */
+    static addScreenshot(filename, description) {
+        if (!(DeviceFarmViewer.isActive && DeviceFarmViewer.session)) {
+            return;
+        }
+        try {
+            DeviceFarmViewer.stepCounter++;
+            const screenshot = {
+                timestamp: new Date().toISOString(),
+                filename,
+                description,
+                step: DeviceFarmViewer.stepCounter,
+                base64: DeviceFarmViewer.loadScreenshotAsDataUri(filename),
+            };
+            DeviceFarmViewer.session.screenshots.push(screenshot);
+            DeviceFarmViewer.session.stepCount = DeviceFarmViewer.stepCounter;
+            DeviceFarmViewer.session.lastUpdate = new Date().toISOString();
+            DeviceFarmViewer.session.status = 'ACTIVE';
+            // ✅ COPIA SCREENSHOT PARA PASTA DO VIEWER
+            DeviceFarmViewer.copyScreenshotToViewer(filename);
+            // Salvar dados atualizados
+            DeviceFarmViewer.saveSessionData();
+            // 🔄 REGENERAR HTML COM DADOS ATUALIZADOS
+            try {
+                DeviceFarmViewer.generateIntegratedHtml();
+            }
+            catch (err) {
+                SimpleLogger.warning(`Erro ao regenerar HTML: ${String(err)}`);
+            }
+            // Sincronizar screenshots do projeto consumidor
+            DeviceFarmViewer.syncConsumerScreenshots();
+            console.log(`📸 Screenshot #${DeviceFarmViewer.stepCounter}: ${description} - HTML atualizado`);
+        }
+        catch (error) {
+            SimpleLogger.warning(`Erro ao adicionar screenshot: ${String(error)}`);
+        }
+    }
+    /**
+     * 📋 Copia screenshot para pasta do viewer para exibição no HTML
+     */
+    static copyScreenshotToViewer(filename) {
+        try {
+            const sourcePath = join('./test-results/mobile-screenshots', filename);
+            const targetPath = join('./test-results/mobile-viewer/screenshots', filename);
+            if (existsSync(sourcePath)) {
+                copyFileSync(sourcePath, targetPath);
+            }
+            else {
+                SimpleLogger.warning(`Screenshot não encontrado: ${sourcePath}`);
+            }
+        }
+        catch (error) {
+            SimpleLogger.warning(`Erro ao copiar screenshot: ${String(error)}`);
+        }
+    }
+    /**
+     * � Garante que todos os screenshots possuam dados base64 embutidos
+     */
+    static ensureBase64ForScreenshots() {
+        if (!DeviceFarmViewer.session) {
+            return;
+        }
+        DeviceFarmViewer.session.screenshots =
+            DeviceFarmViewer.session.screenshots.map((item) => {
+                if (!item.base64) {
+                    item.base64 =
+                        DeviceFarmViewer.loadScreenshotAsDataUri(item.filename) ||
+                            item.base64;
+                }
+                return item;
+            });
+    }
+    /**
+     * 🖼️ Converte screenshot em data URI para uso offline
+     */
+    static loadScreenshotAsDataUri(filename) {
+        if (!filename) {
+            return undefined;
+        }
+        const candidates = new Set();
+        candidates.add(join('./test-results/mobile-viewer/screenshots', filename));
+        candidates.add(join('./test-results/mobile-screenshots', filename));
+        if (DeviceFarmViewer.consumerProjectPath) {
+            candidates.add(join(DeviceFarmViewer.consumerProjectPath, 'test-results', 'mobile-viewer', 'screenshots', filename));
+            candidates.add(join(DeviceFarmViewer.consumerProjectPath, 'test-results', 'mobile-screenshots', filename));
+        }
+        for (const candidate of candidates) {
+            try {
+                if (existsSync(candidate)) {
+                    const buffer = readFileSync(candidate);
+                    const mime = DeviceFarmViewer.detectImageMimeType(candidate);
+                    return `data:${mime};base64,${buffer.toString('base64')}`;
+                }
+            }
+            catch (error) {
+                SimpleLogger.warning(`⚠️ Erro ao embutir screenshot (${candidate}): ${String(error)}`);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * 🧪 Detecta MIME-Type baseado na extensão do arquivo
+     */
+    static detectImageMimeType(filePath) {
+        const ext = filePath.toLowerCase().split('.').pop();
+        switch (ext) {
+            case 'jpg':
+            case 'jpeg':
+                return 'image/jpeg';
+            case 'gif':
+                return 'image/gif';
+            case 'webp':
+                return 'image/webp';
+            case 'bmp':
+                return 'image/bmp';
+            default:
+                return 'image/png';
+        }
+    }
+    /**
+     * �🛑 Para o viewer
+     */
+    static async stop() {
+        if (!(DeviceFarmViewer.isActive && DeviceFarmViewer.session))
+            return;
+        try {
+            DeviceFarmViewer.session.status = 'FINISHED';
+            DeviceFarmViewer.session.endTime = new Date().toISOString();
+            DeviceFarmViewer.session.lastUpdate = new Date().toISOString();
+            await DeviceFarmViewer.saveSessionData();
+            DeviceFarmViewer.isActive = false;
+            SimpleLogger.info(`🛑 Viewer finalizado - Total: ${DeviceFarmViewer.stepCounter} screenshots`);
+        }
+        catch (error) {
+            SimpleLogger.warning(`⚠️ Erro ao finalizar viewer: ${String(error)}`);
+        }
+    }
+    /**
+     * 📁 Criar diretórios necessários
+     */
+    static ensureDirectories() {
+        const dirs = [
+            './test-results/mobile-screenshots',
+            './test-results/mobile-viewer',
+            './test-results/mobile-viewer/screenshots',
+        ];
+        dirs.forEach((dir) => {
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+        });
+    }
+    /**
+     * 💾 Salva dados da sessão
+     */
+    static saveSessionData() {
+        try {
+            const jsonPath = join('./test-results/mobile-viewer', 'session-data.json');
+            DeviceFarmViewer.ensureBase64ForScreenshots();
+            writeFileSync(jsonPath, JSON.stringify(DeviceFarmViewer.session, null, 2), 'utf8');
+        }
+        catch (error) {
+            SimpleLogger.warning(`⚠️ Erro ao salvar dados da sessão: ${String(error)}`);
+        }
+    }
+    /**
+     * 📄 Estado atual (para debugging)
+     */
+    static getStatus() {
+        return {
+            isActive: DeviceFarmViewer.isActive,
+            stepCounter: DeviceFarmViewer.stepCounter,
+            consumerProject: DeviceFarmViewer.consumerProjectPath,
+        };
+    }
+}