@silasfmartins/testhub 1.0.0

package/dist/src/appium/MobileConnection.js

@@ -0,0 +1,772 @@
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import { remote } from 'webdriverio';
+import { GlobalErrorHandler } from '../functions/errors/index.js';
+import { TestContext } from '../testContext/TestContext.js';
+import { Logger } from '../utils/Logger.js';
+import { DeviceFarmViewer } from './DeviceFarmViewer.js';
+import https from 'node:https';
+import { setGlobalDispatcher, Agent } from 'undici';
+import path from 'node:path';
+import fs from 'node:fs';
+/**
+ * ✅ ULTRA-RADICAL MobileConnection - VERSION 2.0 FIXED
+ *
+ * MELHORIAS MANTIDAS:
+ * - 🔥 Ultra-radical closeSession() com múltiplas estratégias de disconnection
+ * - 🔥 Force-kill DeviceFarm sessions via múltiplos endpoints API
+ * - 🔥 Aggressive cleanup: garbage collection, timers, global vars, event listeners
+ * - 📱 Screenshot integration com DeviceFarmViewer (1s polling)
+ * - 🔧 Consumer project detection e cross-project operations
+ * - 🌐 Simple connection strategies com proxy/direct fallback
+ * - 📋 Playwright report integration
+ * - 🛡️ SSL/certificate handling simplificado
+ * - ⚡ Optimized WebDriverIO configurations
+ * - 🔑 API key interna (usuário não precisa configurar)
+ *
+ * CORRIGIDO:
+ * - ❌ Removido require() - 100% ESModules
+ * - ❌ Conectividade simplificada baseada na versão que funcionava
+ * - ❌ SSL killer mais simples e efetivo
+ * - ❌ Fetch com configurações corretas
+ */
+export class MobileConnection {
+    static driver = null;
+    static remoteHost = process.env.DEVICEFARM_HOST || 'devicefarm-qa.com.br';
+    static remotePort = Number.parseInt(process.env.DEVICEFARM_PORT || '443');
+    static remotePath = process.env.DEVICEFARM_PATH || '/api/mobile/wd/hub';
+    static proxyUrl = process.env.HTTPS_PROXY || process.env.HTTP_PROXY || null;
+    // ✅ API KEY INTERNA - Usuário não precisa configurar mais
+    static apiKey = process.env.DEVICEFARM_API_KEY || '75ec082d-f22c-4b17-b872-1a0d4791fa40';
+    // ✅ ULTRA-RADICAL SESSION TRACKING
+    static activeSessionId = null;
+    static connectionTimestamp = Date.now();
+    static forceCleanupExecuted = false;
+    static _isConnected = false;
+    static _currentCapabilities = null;
+    /**
+     * ✅ MAIN CONNECTION METHOD - Ultra-optimized with simple fallback strategies
+     */
+    static async connect(capabilities) {
+        try {
+            // 🚫 Initialize SSL killer first
+            await MobileConnection.initializeGlobalSSLKiller();
+            Logger.bloco('🔧 Iniciando Conexão Mobile com DeviceFarm');
+            Logger.info(`🎯 Host: ${MobileConnection.remoteHost}:${MobileConnection.remotePort}`);
+            Logger.info(`🔑 API Key: ${MobileConnection.apiKey.substring(0, 8)}...`);
+            // ✅ VALIDAÇÃO DE CAPABILITIES
+            MobileConnection.validateCapabilities(capabilities);
+            MobileConnection._currentCapabilities = capabilities;
+            // ✅ VERIFICAR CONECTIVIDADE SIMPLES
+            const connectivityResults = await MobileConnection.checkDeviceFarmConnectivityWithFallback();
+            if (!connectivityResults.success) {
+                throw new Error('❌ DeviceFarm não acessível com nenhuma estratégia de conectividade');
+            }
+            // ✅ CONECTAR USANDO ESTRATÉGIA SIMPLES
+            const driver = await MobileConnection.createSimpleConnection(capabilities, connectivityResults.useProxy);
+            if (!driver?.sessionId) {
+                throw new Error('❌ Falha ao criar sessão mobile');
+            }
+            MobileConnection.driver = driver;
+            MobileConnection.activeSessionId = driver.sessionId;
+            MobileConnection._isConnected = true;
+            // ✅ CONFIGURAR VISUALIZAÇÃO AUTOMÁTICA COM 1 SEGUNDO POLLING
+            await MobileConnection.setupAutomaticVisualization(capabilities);
+            Logger.success(`Conexão mobile estabelecida: ${driver.sessionId}`);
+            return driver;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            // ✅ USAR ERROR HANDLER ADEQUADO
+            const errorHandler = GlobalErrorHandler.getInstance();
+            const errorToHandle = error instanceof Error ? error : new Error(String(error));
+            errorHandler.handleError(errorToHandle, {
+                context: 'MobileConnection.connect',
+                operation: 'Device connection',
+                severity: 'high',
+                metadata: { capabilities },
+            });
+            // ✅ TROUBLESHOOTING INFO
+            MobileConnection.logTroubleshootingInfo();
+            throw new Error(`❌ Falha na conexão mobile: ${errorMsg}`);
+        }
+    }
+    /**
+     * 🔥 ULTRA-RADICAL SESSION TERMINATION - AGGRESSIVE MULTI-LEVEL DISCONNECTION
+     *
+     * Estratégias implementadas:
+     * 1. Stop DeviceFarmViewer
+     * 2. Force-close via DeviceFarm API
+     * 3. Driver termination (deleteSession, quit, closeApp) com timeouts
+     * 4. HTTP/HTTPS agent destruction
+     * 5. Force-kill all DeviceFarm sessions
+     * 6. Ultra-aggressive cleanup (GC, timers, globals, listeners)
+     */
+    static async closeSession() {
+        const sessionId = MobileConnection.activeSessionId || MobileConnection.driver?.sessionId;
+        if (sessionId) {
+            Logger.info(`🎯 Session ID a ser terminada: ${sessionId}`);
+        }
+        // ✅ ESTRATÉGIA 1: STOP DEVICEFARM VIEWER
+        try {
+            await DeviceFarmViewer.stop();
+            Logger.success('DeviceFarmViewer parado');
+        }
+        catch (error) {
+            Logger.warning(`Erro ao parar DeviceFarmViewer: ${String(error)}`);
+        }
+        // ✅ ESTRATÉGIA 2: FORCE-CLOSE VIA DEVICEFARM API
+        if (sessionId) {
+            try {
+                await MobileConnection.forceCloseSessionViaAPI(sessionId);
+                Logger.success('Force-close via API concluído');
+            }
+            catch (error) {
+                Logger.warning(`Erro no force-close via API: ${String(error)}`);
+            }
+        }
+        // ✅ ESTRATÉGIA 3: DRIVER TERMINATION COM MÚLTIPLOS MÉTODOS
+        if (MobileConnection.driver) {
+            try {
+                Logger.info('🔌 Iniciando terminação do driver...');
+                // Múltiplas tentativas de fechamento
+                const terminationMethods = [
+                    {
+                        name: 'deleteSession',
+                        method: () => MobileConnection.driver.deleteSession(),
+                    },
+                    {
+                        name: 'closeApp',
+                        method: () => MobileConnection.driver.closeApp &&
+                            MobileConnection.driver.closeApp(),
+                    },
+                ];
+                for (const { name, method } of terminationMethods) {
+                    try {
+                        await Promise.race([
+                            method(),
+                            new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 10_000)),
+                        ]);
+                        Logger.success(`✅ ${name} concluído`);
+                        break; // Se um funcionou, não precisa tentar os outros
+                    }
+                    catch (error) {
+                        Logger.warning(`⚠️ ${name} falhou: ${String(error)}`);
+                    }
+                }
+            }
+            catch (error) {
+                Logger.warning(`⚠️ Erro na terminação do driver: ${String(error)}`);
+            }
+        }
+        // ✅ ESTRATÉGIA 5: FORCE-KILL ALL DEVICEFARM SESSIONS
+        try {
+            await MobileConnection.forceKillAllDeviceFarmSessions();
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro no force-kill all sessions: ${String(error)}`);
+        }
+        // ✅ ESTRATÉGIA 6: ULTRA-AGGRESSIVE CLEANUP
+        try {
+            await MobileConnection.forceCleanup();
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro no ultra-aggressive cleanup: ${String(error)}`);
+        }
+        // ✅ RESET INTERNAL STATE
+        MobileConnection.driver = null;
+        MobileConnection.activeSessionId = null;
+        MobileConnection._isConnected = false;
+        MobileConnection.forceCleanupExecuted = true;
+    }
+    /**
+     * 🔥 FORCE-CLOSE SESSION VIA DEVICEFARM API
+     */
+    static async forceCloseSessionViaAPI(sessionId) {
+        const endpoints = [
+            `/api/mobile/sessions/${sessionId}/force-close`,
+            `/api/mobile/sessions/${sessionId}/terminate`,
+            `/api/sessions/${sessionId}/close`,
+            `/api/mobile/force-disconnect/${sessionId}`,
+        ];
+        for (const endpoint of endpoints) {
+            try {
+                const url = `https://${MobileConnection.remoteHost}${endpoint}`;
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'X-API-Key': MobileConnection.apiKey,
+                        'Content-Type': 'application/json',
+                    },
+                });
+                if (response.ok) {
+                    Logger.success(`✅ Force-close bem-sucedido: ${endpoint}`);
+                    return;
+                }
+            }
+            catch (error) {
+                Logger.warning(`⚠️ Force-close falhou ${endpoint}: ${String(error)}`);
+            }
+        }
+    }
+    /**
+     * 💀 FORCE-KILL ALL DEVICEFARM SESSIONS - NUCLEAR OPTION
+     */
+    static async forceKillAllDeviceFarmSessions() {
+        const killEndpoints = [
+            '/api/mobile/sessions/kill-all',
+            '/api/mobile/force-disconnect',
+            '/api/sessions/cleanup',
+            '/api/mobile/emergency-shutdown',
+            '/api/admin/force-cleanup',
+        ];
+        for (const endpoint of killEndpoints) {
+            try {
+                const url = `https://${MobileConnection.remoteHost}${endpoint}`;
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'X-API-Key': MobileConnection.apiKey,
+                        'Content-Type': 'application/json',
+                    },
+                });
+                if (response.ok) {
+                    Logger.info(`✅ Force-kill endpoint funcionou: ${endpoint}`);
+                }
+            }
+            catch (error) {
+                // Silencioso para endpoints de emergência
+            }
+        }
+    }
+    /**
+     * 🧹 ULTRA-AGGRESSIVE FORCE CLEANUP - NUCLEAR CLEANUP OPTION (ESModules Fixed)
+     */
+    static async forceCleanup() {
+        if (MobileConnection.forceCleanupExecuted) {
+            return;
+        }
+        // ✅ 1. GARBAGE COLLECTION FORÇADO
+        try {
+            if (typeof globalThis.gc === 'function') {
+                globalThis.gc();
+            }
+        }
+        catch (error) {
+            // GC pode não estar disponível
+        }
+        // ✅ 2. CLEAR ALL TIMERS E INTERVALS
+        try {
+            // ESModules way - sem require() - fix timeout type
+            const highestTimeoutId = Number(setTimeout(() => { }, 0));
+            for (let i = 0; i <= highestTimeoutId; i++) {
+                clearTimeout(i);
+                clearInterval(i);
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao limpar timers: ${String(error)}`);
+        }
+        // ✅ 3. CLEAR GLOBAL VARIABLES (ESModules compatible)
+        try {
+            // ESModules não tem require.cache - usar strategy alternativa
+            const keysToDelete = Object.keys(globalThis).filter((key) => key.includes('webdriverio') ||
+                key.includes('appium') ||
+                key.includes('selenium') ||
+                key.includes('devicefarm') ||
+                key.startsWith('mobile'));
+            keysToDelete.forEach((key) => {
+                try {
+                    delete globalThis[key];
+                }
+                catch {
+                    // Ignorar se não conseguir deletar
+                }
+            });
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao limpar variáveis globais: ${String(error)}`);
+        }
+        // ✅ 4. REMOVE EVENT LISTENERS
+        try {
+            if (typeof process !== 'undefined' && process.removeAllListeners) {
+                const events = [
+                    'exit',
+                    'SIGINT',
+                    'SIGTERM',
+                    'uncaughtException',
+                    'unhandledRejection',
+                ];
+                events.forEach((event) => {
+                    try {
+                        process.removeAllListeners(event);
+                    }
+                    catch {
+                        // Ignorar se não conseguir remover
+                    }
+                });
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao remover event listeners: ${String(error)}`);
+        }
+        // ✅ 5. FORCE MEMORY RELEASE
+        try {
+            // Forçar liberação de memória
+            MobileConnection.driver = null;
+            MobileConnection.activeSessionId = null;
+            MobileConnection._isConnected = false;
+            // Set imediato para garantir que GC rode
+            setImmediate(() => {
+                if (typeof globalThis.gc === 'function') {
+                    globalThis.gc();
+                }
+            });
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro na liberação de memória: ${String(error)}`);
+        }
+        // ✅ 6. WAIT AND FINAL GC
+        try {
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            if (typeof globalThis.gc === 'function') {
+                globalThis.gc();
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro no cleanup final: ${String(error)}`);
+        }
+        MobileConnection.forceCleanupExecuted = true;
+    }
+    /**
+     * ✅ SIMPLE CONNECTION CREATION - Baseado na versão que funcionava
+     */
+    static async createSimpleConnection(capabilities, useProxy) {
+        // ✅ PREPARAR CAPABILITIES BÁSICAS
+        const fullCapabilities = {
+            'appium:apiKey': MobileConnection.apiKey,
+            'appium:deviceId': capabilities.deviceId || capabilities.deviceName,
+            'appium:automationName': capabilities.platformName === 'Android' ? 'UiAutomator2' : 'XCUITest',
+            'appium:platformName': capabilities.platformName,
+            'appium:noReset': true,
+            'appium:newCommandTimeout': 300,
+            'appium:autoGrantPermissions': true,
+            'appium:realDevice': true,
+            // Android específico
+            ...(capabilities.platformName === 'Android' && {
+                'appium:appPackage': capabilities.appPackage,
+                'appium:appActivity': capabilities.appActivity,
+            }),
+            // iOS específico
+            ...(capabilities.platformName === 'iOS' && {
+                'appium:bundleId': capabilities.bundleId,
+            }),
+        };
+        // ✅ PREPARAR CONFIGURAÇÕES WEBDRIVER
+        const agent = useProxy
+            ? await MobileConnection.setupProxy()
+            : await MobileConnection.setupSSLAgent();
+        const webdriverOptions = {
+            protocol: 'https',
+            hostname: MobileConnection.remoteHost,
+            port: MobileConnection.remotePort,
+            path: MobileConnection.remotePath,
+            capabilities: {
+                alwaysMatch: fullCapabilities,
+                firstMatch: [{}],
+            },
+            logLevel: 'silent',
+            connectionRetryCount: 2,
+            connectionRetryTimeout: 60_000,
+            requestTimeout: 120_000,
+            agent,
+            headers: {
+                'User-Agent': 'AutoCore-Mobile/2.0',
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+        };
+        Logger.info('🔌 Criando sessão WebDriverIO...');
+        // ✅ CRIAR DRIVER COM TIMEOUT
+        const driver = await Promise.race([
+            remote(webdriverOptions),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('❌ Timeout na criação de sessão (120s)')), 120_000)),
+        ]);
+        if (!driver?.sessionId) {
+            throw new Error('❌ Driver criado mas sessionId não encontrado');
+        }
+        Logger.success(`Sessão criada: ${driver.sessionId}`);
+        return driver;
+    }
+    /**
+     * ✅ CONNECTIVITY CHECK WITH FALLBACK STRATEGIES - Simplificado
+     */
+    static async checkDeviceFarmConnectivityWithFallback() {
+        // Estratégia 1: Proxy
+        try {
+            const withProxy = await MobileConnection.checkConnectivity(true);
+            if (withProxy) {
+                return { success: true, method: 'proxy corporativo', useProxy: true };
+            }
+        }
+        catch (error) {
+            Logger.warning(`Conectividade com proxy falhou: ${String(error)}`);
+        }
+        // Estratégia 2: Direto
+        try {
+            Logger.info('📡 Tentativa 2: Conectividade direta (sem proxy)...');
+            const direct = await MobileConnection.checkConnectivity(false);
+            if (direct) {
+                return { success: true, method: 'conexão direta', useProxy: false };
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ ⚠️ Conectividade direta falhou: ${String(error)}`);
+        }
+        // Estratégia 3: SSL relaxado
+        try {
+            Logger.info('ℹ️  📡 Tentativa 3: Conectividade com SSL relaxado...');
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+            const sslRelaxed = await MobileConnection.checkConnectivity(false);
+            if (sslRelaxed) {
+                return { success: true, method: 'SSL relaxado', useProxy: false };
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ ⚠️ Conectividade direta falhou: ${String(error)}`);
+        }
+        // Estratégia 4: Múltiplas tentativas
+        Logger.info('ℹ️  📡 Tentativa 4: Múltiplas tentativas com timeout otimizado...');
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            try {
+                Logger.info(`ℹ️  🔄 Tentativa ${attempt}/3 com timeout otimizado...`);
+                const result = await MobileConnection.testBasicEndpoint();
+                if (result) {
+                    return {
+                        success: true,
+                        method: `tentativa otimizada ${attempt}`,
+                        useProxy: false,
+                    };
+                }
+            }
+            catch (error) {
+                Logger.error(`❌ Erro inesperado: ${String(error)}...`);
+                if (attempt < 3) {
+                    Logger.info('⏱️ Aguardando 3s antes da próxima tentativa...');
+                    await new Promise((resolve) => setTimeout(resolve, 3000));
+                }
+            }
+        }
+        return { success: false, method: 'nenhum', useProxy: false };
+    }
+    /**
+     * ✅ BASIC CONNECTIVITY CHECK - Simplificado
+     */
+    static async checkConnectivity(useProxy) {
+        try {
+            const url = `https://${MobileConnection.remoteHost}:${MobileConnection.remotePort}/api/health`;
+            const options = {
+                method: 'GET',
+                headers: {
+                    'User-Agent': 'AutoCore-Mobile-Test/2.0',
+                    Accept: 'application/json',
+                },
+            };
+            if (useProxy && MobileConnection.proxyUrl) {
+                options.agent = new HttpsProxyAgent(MobileConnection.proxyUrl);
+            }
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 15_000);
+            options.signal = controller.signal;
+            const response = await fetch(url, options);
+            clearTimeout(timeoutId);
+            return response.status < 500;
+        }
+        catch (error) {
+            throw new Error(`Conectividade falhou: ${String(error)}`);
+        }
+    }
+    /**
+     * ✅ TEST BASIC ENDPOINT - Simplificado
+     */
+    static async testBasicEndpoint() {
+        try {
+            Logger.info('🎯 Testando endpoint DeviceFarm com configurações otimizadas...');
+            const url = `https://${MobileConnection.remoteHost}:${MobileConnection.remotePort}/api/mobile/status`;
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 10_000);
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'User-Agent': 'AutoCore-Mobile-Test/2.0',
+                    Accept: 'application/json',
+                    Connection: 'close',
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            return response.status < 500;
+        }
+        catch (error) {
+            throw new Error(`Test endpoint falhou: ${String(error)}`);
+        }
+    }
+    /**
+     * 🎬 SETUP AUTOMATIC VISUALIZATION - COM 1 SEGUNDO POLLING
+     */
+    static async setupAutomaticVisualization(capabilities) {
+        try {
+            if (!MobileConnection.driver?.sessionId) {
+                Logger.warning('⚠️ Sem sessão ativa para configurar visualização');
+                return;
+            }
+            const deviceId = capabilities.deviceId || capabilities.deviceName || 'unknown';
+            Logger.info('🎬 Configurando visualização automática...');
+            // ✅ INICIAR DEVICEFARM VIEWER COM 1 SEGUNDO DE POLLING
+            const htmlPath = await DeviceFarmViewer.start(deviceId);
+            if (htmlPath) {
+                Logger.info('📱 VISUALIZADOR MOBILE ATIVO (1s refresh)!');
+                Logger.info(`📄 Arquivo HTML: ${htmlPath}`);
+                // Capturar screenshot inicial
+                const screenshot = await MobileConnection.captureScreenshot('Conexão estabelecida');
+                if (screenshot) {
+                    Logger.info('📸 Screenshot inicial capturado');
+                }
+            }
+        }
+        catch (error) {
+            Logger.warning(`Erro na configuração de visualização: ${String(error)}`);
+        }
+    }
+    /**
+     * ✅ SETUP PROXY CONFIGURATION
+     */
+    static async setupProxy() {
+        if (!MobileConnection.proxyUrl) {
+            return null;
+        }
+        try {
+            const agent = new HttpsProxyAgent(MobileConnection.proxyUrl, {
+                rejectUnauthorized: false,
+                requestCert: false,
+            });
+            Logger.info(`🔄 Proxy configurado: ${MobileConnection.proxyUrl}`);
+            return agent;
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao configurar proxy: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * ✅ SETUP SSL AGENT - Simples mas efetivo
+     */
+    static async setupSSLAgent() {
+        try {
+            return new https.Agent({
+                rejectUnauthorized: false,
+                requestCert: false,
+                checkServerIdentity: () => undefined,
+                keepAlive: true,
+                maxSockets: 50,
+            });
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao configurar SSL Agent: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * ✅ INITIALIZE GLOBAL SSL KILLER - Simples mas efetivo
+     */
+    static async initializeGlobalSSLKiller() {
+        try {
+            // ✅ NÍVEL 1: Environment variables
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+            process.env.HTTPS_PROXY_REJECT_UNAUTHORIZED = '0';
+            process.env.SSL_VERIFY = '0';
+            // ✅ NÍVEL 2: Global fetch override
+            if (typeof globalThis.fetch !== 'undefined') {
+                const originalFetch = globalThis.fetch;
+                globalThis.fetch = async function (input, init = {}) {
+                    // Aplicar SSL bypass para DeviceFarm
+                    const url = typeof input === 'string' ? input : input?.url || '';
+                    if ((url.includes('devicefarm') || url.includes('.com.br')) &&
+                        !init.agent) {
+                        try {
+                            init.agent = new https.Agent({
+                                rejectUnauthorized: false,
+                                checkServerIdentity: () => undefined,
+                            });
+                        }
+                        catch {
+                            // Fallback se não conseguir criar agent
+                        }
+                    }
+                    return originalFetch.call(this, input, init);
+                };
+            }
+            // ✅ NÍVEL 3: Undici configuration
+            try {
+                setGlobalDispatcher(new Agent({
+                    connect: {
+                        rejectUnauthorized: false,
+                        checkServerIdentity: () => undefined,
+                    },
+                }));
+            }
+            catch {
+                // Undici pode não estar disponível
+            }
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao configurar SSL Killer: ${String(error)}`);
+            // Fallback básico
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+        }
+    }
+    /**
+     * ✅ ENHANCED SCREENSHOT CAPTURE WITH EVIDENCE INTEGRATION
+     */
+    static async captureScreenshot(description = 'Mobile Screenshot') {
+        try {
+            if (!MobileConnection.driver) {
+                Logger.warning('Sem driver ativo para screenshot');
+                return null;
+            }
+            const screenshot = await MobileConnection.driver.takeScreenshot();
+            if (!screenshot)
+                return null;
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const fileName = `mobile-${timestamp}-${description.replace(/[^a-zA-Z0-9]/g, '_')}.png`;
+            const screenshotDir = path.resolve('./test-results/mobile-screenshots');
+            if (!fs.existsSync(screenshotDir)) {
+                fs.mkdirSync(screenshotDir, { recursive: true });
+            }
+            const screenshotPath = path.join(screenshotDir, fileName);
+            fs.writeFileSync(screenshotPath, screenshot, 'base64');
+            // ✅ ANEXAR AO PLAYWRIGHT
+            const testInfo = TestContext.getSafeTestInfo();
+            if (testInfo) {
+                await testInfo.attach(`mobile-${description}`, {
+                    body: Buffer.from(screenshot, 'base64'),
+                    contentType: 'image/png',
+                });
+            }
+            // ✅ ADICIONAR AO VIEWER COM 1 SEGUNDO POLLING
+            try {
+                DeviceFarmViewer.addScreenshot(fileName, description);
+            }
+            catch (error) {
+                // Silencioso se viewer não estiver disponível
+            }
+            Logger.info(`📸 Screenshot salvo: ${fileName}`);
+            return screenshotPath;
+        }
+        catch (error) {
+            Logger.error(`Erro ao capturar screenshot: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * ✅ VALIDATE CAPABILITIES
+     */
+    static validateCapabilities(capabilities) {
+        if (!(capabilities.deviceId || capabilities.deviceName)) {
+            throw new Error('Device ID é obrigatório');
+        }
+        if (capabilities.platformName === 'Android' && !capabilities.appPackage) {
+            throw new Error('App Package é obrigatório para Android');
+        }
+        if (capabilities.platformName === 'iOS' && !capabilities.bundleId) {
+            throw new Error('Bundle ID é obrigatório para iOS');
+        }
+    }
+    /**
+     * ✅ GET DRIVER INSTANCE
+     */
+    static getDriver() {
+        return MobileConnection.driver;
+    }
+    /**
+     * ✅ GET CURRENT DEVICE ID
+     */
+    static getCurrentDeviceId() {
+        return (MobileConnection._currentCapabilities?.deviceId ||
+            MobileConnection._currentCapabilities?.deviceName ||
+            'unknown-device');
+    }
+    /**
+     * ✅ GET CURRENT PLATFORM
+     */
+    static getCurrentPlatform() {
+        return MobileConnection._currentCapabilities?.platformName || 'Android';
+    }
+    /**
+     * ✅ CAPTURE EVIDENCE (ALIAS FOR SCREENSHOT)
+     */
+    static async captureEvidence(description = 'Evidence') {
+        return await MobileConnection.captureScreenshot(description);
+    }
+    /**
+     * ✅ IS CONNECTED CHECK
+     */
+    static isConnected() {
+        return (MobileConnection._isConnected &&
+            MobileConnection.driver !== null &&
+            !!MobileConnection.driver?.sessionId);
+    }
+    /**
+     * ✅ VERIFY DEVICEFARM VISUAL CONNECTION
+     */
+    static async verifyDeviceFarmVisualConnection() {
+        try {
+            const screenshot = await MobileConnection.captureScreenshot('Test connectivity');
+            return !!screenshot;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * ✅ TAKE SCREENSHOT (ALIAS)
+     */
+    static async takeScreenshot() {
+        return await MobileConnection.captureScreenshot();
+    }
+    /**
+     * ✅ CAPTURE SCREENSHOT AS BUFFER
+     */
+    static async captureScreenshotBuffer(description = 'Mobile Screenshot') {
+        try {
+            if (!MobileConnection.driver)
+                return null;
+            const screenshot = await MobileConnection.driver.takeScreenshot();
+            if (!screenshot)
+                return null;
+            return Buffer.from(screenshot, 'base64');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * ✅ CREATE SESSION (ALIAS FOR CONNECT)
+     */
+    static async createSession(capabilities) {
+        return await MobileConnection.connect(capabilities);
+    }
+    /**
+     * ✅ TROUBLESHOOTING INFO
+     */
+    static logTroubleshootingInfo() {
+        Logger.info('🔧 === TROUBLESHOOTING MOBILE ===');
+        Logger.info('💡 Se a conexão mobile falhar:');
+        Logger.info('ℹ️     1. ✅ Verificar se Device Farm está online');
+        Logger.info('ℹ️     2. ✅ API key é automática (DEVICEFARM_API_KEY opcional)');
+        Logger.info('ℹ️     3. ✅ Verificar se device está disponível');
+        Logger.info('ℹ️     4. ✅ Testar conectividade de rede');
+        Logger.info('ℹ️     5. ✅ Verificar proxy se necessário');
+        Logger.info(`ℹ️     6. ✅ Host: ${MobileConnection.remoteHost}:${MobileConnection.remotePort}`);
+        Logger.info('ℹ️     7. ✅ Tentativas: proxy → direto → SSL relaxado');
+    }
+}