@silasfmartins/testhub 1.0.0

package/dist/src/utils/ActionInterceptor.js

@@ -0,0 +1,741 @@
+/**
+ * 🔧 Sistema de Interceptação para Captura Automática de Evidências
+ * @description Intercepta ações do WebActions, MobileActions e ApiActions para capturar evidências
+ * @author TestHUB Team
+ * @version 1.0.0
+ */
+import { TestContext } from "../testContext/TestContext.js";
+import { EvidenceCapture } from "./EvidenceCapture.js";
+import { createFrameHelper } from "./FrameManagementUtil.js";
+import { Logger } from "./Logger.js";
+import { analyzeFailure, markSuccess, reportResult, getRecoveryMetadata, } from "./testRecovery/TestRecoveryClient.js";
+export class ActionInterceptor {
+    static isInitialized = false;
+    static interceptedMethods = new Set();
+    /**
+     * ✅ Inicializa os interceptadores
+     */
+    static initialize() {
+        if (ActionInterceptor.isInitialized)
+            return;
+        ActionInterceptor.isInitialized = true;
+        // Aguardar um pouco para garantir que os módulos foram carregados
+        setTimeout(() => {
+            ActionInterceptor.interceptWebActions();
+            ActionInterceptor.interceptMobileActions();
+            ActionInterceptor.interceptApiActions();
+            ActionInterceptor.interceptDesktopActions();
+        }, 100);
+    }
+    /**
+     * ✅ Intercepta WebActions
+     */
+    static interceptWebActions() {
+        try {
+            // Importação dinâmica para evitar dependência circular
+            import("../playwright/WebActions.js")
+                .then(({ WebActions }) => {
+                const methodsToIntercept = [
+                    "click",
+                    "switchTo",
+                    "fill",
+                    "type",
+                    "press",
+                    "selectOption",
+                    "check",
+                    "uncheck",
+                    "hover",
+                    "dragAndDrop",
+                    "navigate",
+                    "waitForElement",
+                    "waitForText",
+                ];
+                methodsToIntercept.forEach((methodName) => {
+                    ActionInterceptor.interceptMethod(WebActions, methodName, "Web");
+                });
+            })
+                .catch(() => {
+                // Ignorar se não conseguir importar
+            });
+        }
+        catch (error) {
+            // Ignorar erros de interceptação
+        }
+    }
+    /**
+     * ✅ Intercepta DesktopActions
+     */
+    static interceptDesktopActions() {
+        try {
+            import("../desktop/DesktopActions.js")
+                .then(({ DesktopActions }) => {
+                const methodsToIntercept = [
+                    "click",
+                    "setText",
+                    "doubleClick",
+                    "selectInTableActiveRow",
+                    "clickOptionInTable",
+                    "clickOptionInTableRowAndHeader",
+                    "doubleClickOptionInTable",
+                    "selectRowInTable",
+                    "selectRowOptionInTable",
+                    "selectInTreeView",
+                    "selectInTabControl",
+                    "setValueTable",
+                    "setStateCheckBox",
+                    "implicitWait",
+                    "selectInList",
+                    "validateObject",
+                    "getText",
+                    "getLabel",
+                    "closeWindow",
+                    "maximizeWindow",
+                    "pressKey",
+                    "releaseKey",
+                    "waitForElementJavaToDisappear",
+                ];
+                methodsToIntercept.forEach((methodName) => {
+                    ActionInterceptor.interceptMethod(DesktopActions, methodName, "Web");
+                });
+            })
+                .catch(() => {
+                // Ignorar se não conseguir importar
+            });
+        }
+        catch (error) {
+            // Ignorar erros de interceptação
+        }
+    }
+    /**
+     * ✅ Intercepta MobileActions
+     */
+    static interceptMobileActions() {
+        try {
+            import("../appium/MobileActions.js")
+                .then(({ MobileActions }) => {
+                const methodsToIntercept = [
+                    "click",
+                    "setText",
+                    "tap",
+                    "swipe",
+                    "scroll",
+                    "waitForElement",
+                    "longPress",
+                    "doubleClick",
+                    "dragAndDrop",
+                    "hideKeyboard",
+                    "swipeLeft",
+                    "swipeRight",
+                    "swipeUp",
+                    "swipeDown",
+                    "pinch",
+                    "zoom",
+                ];
+                methodsToIntercept.forEach((methodName) => {
+                    ActionInterceptor.interceptMethod(MobileActions, methodName, "Mobile");
+                });
+            })
+                .catch(() => {
+                // Ignorar se não conseguir importar
+            });
+        }
+        catch (error) {
+            // Ignorar erros de interceptação
+        }
+    }
+    /**
+     * 🚫 Intercepta ApiActions - DESABILITADO
+     * Métodos do ApiActions são internos e não devem ser capturados como CTs
+     */
+    static interceptApiActions() {
+        // 🚫 DESABILITADO: ApiActions são métodos internos que não devem ser capturados como CTs
+        return;
+        /* CÓDIGO ORIGINAL DESABILITADO
+    try {
+      import('../api/ApiActions.js').then(({ ApiActions }) => {
+        const methodsToIntercept = [
+          'get',
+          'post',
+          'put',
+          'delete',
+          'patch',
+          'request'
+        ]
+
+        methodsToIntercept.forEach(methodName => {
+          ActionInterceptor.interceptMethod(ApiActions, methodName, 'API')
+        })
+      }).catch(() => {
+        // Ignorar se não conseguir importar
+      })
+    } catch (error) {
+      // Ignorar erros de interceptação
+    }
+    */
+    }
+    /**
+     * ✅ Intercepta um método específico
+     */
+    static interceptMethod(targetClass, methodName, actionType) {
+        const key = `${targetClass.name}.${methodName}`;
+        if (ActionInterceptor.interceptedMethods.has(key))
+            return;
+        const originalMethod = targetClass[methodName];
+        if (!originalMethod || typeof originalMethod !== "function")
+            return;
+        targetClass[methodName] = async function (...args) {
+            let testName = "Unknown Test";
+            let description = "";
+            try {
+                // Obter nome do teste atual
+                const testInfo = TestContext.getSafeTestInfo();
+                if (testInfo?.title) {
+                    testName = testInfo.title;
+                }
+                // Gerar descrição da ação
+                description = ActionInterceptor.generateActionDescription(methodName, args, actionType);
+                // Capturar evidência ANTES da ação (estado inicial)
+                await EvidenceCapture.captureAction(testName, `${actionType}: ${methodName}`, `🎯 INICIANDO: ${description}`);
+                // Executar método original
+                const result = await originalMethod.apply(this, args);
+                // Capturar evidência DEPOIS da ação (resultado)
+                await EvidenceCapture.captureAction(testName, `${actionType}: ${methodName}`, `✅ CONCLUÍDO: ${description}`);
+                return result;
+            }
+            catch (error) {
+                // Capturar evidência de erro
+                await EvidenceCapture.captureAction(testName, `${actionType}: ${methodName}`, `❌ ERRO: ${description} - ${error}`);
+                // Tentativa de auto-recovery apenas para ações Web relevantes
+                try {
+                    const recoverable = [
+                        "click",
+                        "fill",
+                        "type",
+                        "press",
+                        "selectOption",
+                        "check",
+                        "uncheck",
+                        "hover",
+                        "switchTo",
+                    ];
+                    const MIN_CONF = Number(process.env.AUTOCORE_RECOVERY_MIN_CONFIDENCE || "0.7");
+                    const MAX_RETRIES_DEFAULT = Number(process.env.AUTOCORE_RECOVERY_MAX_RETRIES || "8");
+                    if (actionType === "Web" && recoverable.includes(methodName)) {
+                        const failedXPath = ActionInterceptor.extractSelector(args[0]);
+                        const actionTypeStr = (() => {
+                            switch (methodName) {
+                                case "click":
+                                    return "click";
+                                case "switchTo":
+                                    return "switchTo";
+                                case "fill":
+                                case "type":
+                                    return "fill";
+                                case "press":
+                                    return "press";
+                                case "selectOption":
+                                    return "select";
+                                case "check":
+                                    return "check";
+                                case "uncheck":
+                                    return "uncheck";
+                                case "hover":
+                                    return "hover";
+                                default:
+                                    return "click";
+                            }
+                        })();
+                        const pageUrl = TestContext.isPageInitialized()
+                            ? TestContext.getPage().url()
+                            : undefined;
+                        // Obter filledInputs/filledFields do singleton e metadados (v2.7.44)
+                        let filledInputs = [];
+                        let filledFields = [];
+                        try {
+                            const { testRecoveryHelper } = await import("./testRecovery/TestRecoveryClient.js");
+                            filledInputs = testRecoveryHelper.getFilledInputs();
+                            filledFields = testRecoveryHelper.getFilledFields();
+                        }
+                        catch { }
+                        const recoveryMeta = getRecoveryMetadata();
+                        // Obter metadados de página do stack trace (item 20 v2.7.44)
+                        let pageMeta = {};
+                        try {
+                            const mod = await import("../playwright/WebActions.js").catch(() => null);
+                            const WA = mod ? mod.WebActions : null;
+                            if (WA && typeof WA.getCallerPageMetadata === "function") {
+                                pageMeta = WA.getCallerPageMetadata();
+                            }
+                        }
+                        catch { }
+                        const contextPayload = {
+                            text: typeof args[1] === "string" ? args[1] : undefined,
+                            value: typeof args[1] === "string" ? args[1] : undefined,
+                            originalMethod: methodName,
+                            filledInputs,
+                            filledFields,
+                            pageFileName: pageMeta.pageFileName,
+                            pageName: pageMeta.pageName,
+                            pageObjectName: pageMeta.pageObjectName,
+                        };
+                        // Capturar contexto de página para melhor análise
+                        let pageStructure = undefined;
+                        let pageHtml;
+                        try {
+                            if (TestContext.isPageInitialized()) {
+                                const page = TestContext.getPage();
+                                // Tentar importar WebActions para usar extractBasicPageStructure
+                                const mod = await import("../playwright/WebActions.js").catch(() => null);
+                                const WebActionsLocal = mod ? mod.WebActions : null;
+                                if (WebActionsLocal &&
+                                    typeof WebActionsLocal.extractBasicPageStructure ===
+                                        "function") {
+                                    pageStructure =
+                                        await WebActionsLocal.extractBasicPageStructure(page).catch(() => undefined);
+                                }
+                                // Fallback: capturar HTML se não conseguiu estrutura
+                                if (!pageStructure) {
+                                    const html = await page.content().catch(() => "");
+                                    if (html) {
+                                        pageHtml =
+                                            html.length > 50000
+                                                ? html.substring(0, 50000) + "... (truncated)"
+                                                : html;
+                                    }
+                                }
+                            }
+                        }
+                        catch { }
+                        // Detectar tipo de erro a partir da exceção
+                        const detectErrorType = (err) => {
+                            const msg = err && err.message
+                                ? String(err.message).toLowerCase()
+                                : String(err || "").toLowerCase();
+                            if (msg.includes("strict mode violation") ||
+                                msg.includes("multiple elements"))
+                                return "multiple_elements";
+                            if (msg.includes("timeout") ||
+                                msg.includes("timed out") ||
+                                err?.code === "ETIMEDOUT")
+                                return "timeout";
+                            if (msg.includes("detached") || msg.includes("stale"))
+                                return "stale_element";
+                            if (msg.includes("navigation") && msg.includes("wrong"))
+                                return "wrong_navigation";
+                            return "not_found";
+                        };
+                        const detectedErrorType = detectErrorType(error);
+                        Logger.info(`[ActionInterceptor] 🔍 AutoHealing: chamando analyze-failure para XPath "${failedXPath}" (${detectedErrorType}, executionSource=${recoveryMeta.executionSource})`);
+                        const response = await analyzeFailure({
+                            url: pageUrl || "",
+                            failedXPath,
+                            errorType: detectedErrorType,
+                            actionType: actionTypeStr,
+                            sessionId: TestContext.getOrCreateSessionId(),
+                            executionSource: recoveryMeta.executionSource,
+                            testCaseName: recoveryMeta.testCaseName,
+                            testCaseId: recoveryMeta.testCaseId,
+                            testMethodName: recoveryMeta.testMethodName,
+                            context: contextPayload,
+                            pageStructure,
+                            pageHtml,
+                        });
+                        if (!response) {
+                            Logger.warning(`[ActionInterceptor] ⚠️ AutoHealing: sem resposta do backend (verifique AUTOCORE_HUB_URL ou conectividade)`);
+                        }
+                        else if (!response.analysis ||
+                            !response.analysis.suggestedXPath) {
+                            Logger.warning(`[ActionInterceptor] ⚠️ AutoHealing: backend não encontrou XPath alternativo para "${failedXPath}"`);
+                        }
+                        if (response &&
+                            response.analysis &&
+                            response.analysis.suggestedXPath) {
+                            const { suggestedXPath, confidence } = response.analysis;
+                            if (confidence < MIN_CONF) {
+                                Logger.warning(`[ActionInterceptor] ⚠️ AutoHealing: confiança ${(confidence * 100).toFixed(0)}% abaixo do mínimo (${(MIN_CONF * 100).toFixed(0)}%). XPath sugerido: "${suggestedXPath}"`);
+                            }
+                            if (confidence >= MIN_CONF) {
+                                // Executar ações recomendadas antes do retry (v2.7.43)
+                                const frameHelper = createFrameHelper();
+                                if (response.actions && response.actions.length) {
+                                    for (const a of response.actions) {
+                                        try {
+                                            // Tentar usar as Actions do framework quando possível
+                                            const mod = await import("../playwright/WebActions.js").catch(() => null);
+                                            const WebActions = mod ? mod.WebActions : null;
+                                            switch (a.type) {
+                                                case "wait":
+                                                    if (TestContext.isPageInitialized())
+                                                        await TestContext.getPage().waitForTimeout(a.waitMs || 1000);
+                                                    break;
+                                                case "click_other":
+                                                    if (WebActions &&
+                                                        typeof WebActions.click === "function") {
+                                                        try {
+                                                            await WebActions.click(a.selector || "", "", false);
+                                                        }
+                                                        catch { }
+                                                    }
+                                                    else {
+                                                        try {
+                                                            if (TestContext.isPageInitialized())
+                                                                await TestContext.getPage()
+                                                                    .locator(a.selector || "")
+                                                                    .click();
+                                                        }
+                                                        catch { }
+                                                    }
+                                                    break;
+                                                case "navigate":
+                                                    if (WebActions &&
+                                                        typeof WebActions.navigate === "function") {
+                                                        try {
+                                                            if (a.url)
+                                                                await WebActions.navigate(a.url);
+                                                        }
+                                                        catch { }
+                                                    }
+                                                    else {
+                                                        try {
+                                                            if (a.url && TestContext.isPageInitialized())
+                                                                await TestContext.getPage().goto(a.url);
+                                                        }
+                                                        catch { }
+                                                    }
+                                                    break;
+                                                case "refresh":
+                                                    if (WebActions &&
+                                                        typeof WebActions.refresh === "function") {
+                                                        try {
+                                                            await WebActions.refresh();
+                                                        }
+                                                        catch { }
+                                                    }
+                                                    else {
+                                                        try {
+                                                            if (TestContext.isPageInitialized())
+                                                                await TestContext.getPage().reload();
+                                                        }
+                                                        catch { }
+                                                    }
+                                                    break;
+                                                case "switch_frame":
+                                                    if (a.selector) {
+                                                        try {
+                                                            await frameHelper.switchTo(a.selector);
+                                                        }
+                                                        catch { }
+                                                    }
+                                                    break;
+                                                default:
+                                                    break;
+                                            }
+                                        }
+                                        catch { }
+                                    }
+                                }
+                                // Preparar candidatos: suggested + alternatives
+                                const alternatives = response.analysis.alternatives || [];
+                                const candidates = [];
+                                if (suggestedXPath)
+                                    candidates.push(suggestedXPath);
+                                if (Array.isArray(alternatives) && alternatives.length)
+                                    candidates.push(...alternatives);
+                                const maxRetries = MAX_RETRIES_DEFAULT;
+                                let attemptNumber = 2; // primeira tentativa de recovery é tentativa 2
+                                const logId = response.logId;
+                                for (; attemptNumber <= Math.max(2, maxRetries); attemptNumber++) {
+                                    const candidateIndex = Math.min(attemptNumber - 2, candidates.length - 1);
+                                    const candidate = candidates.length
+                                        ? candidates[candidateIndex]
+                                        : suggestedXPath;
+                                    if (!candidate)
+                                        break;
+                                    // Gerenciar contexto de frame (v2.7.43)
+                                    await frameHelper.switchToDefaultIfNeeded();
+                                    // Re-executar switch_frame antes de cada tentativa
+                                    if (response.actions && response.actions.length) {
+                                        await frameHelper.applySwitchFrameActions(response.actions);
+                                    }
+                                    try {
+                                        const newArgs = [...args];
+                                        newArgs[0] = candidate;
+                                        const retryResult = await originalMethod.apply(this, newArgs);
+                                        // Gerenciar contexto de frame (v2.7.43)
+                                        await frameHelper.switchToDefaultIfNeeded();
+                                        // Capturar evidência de sucesso após retry
+                                        await EvidenceCapture.captureAction(testName, `${actionType}: ${methodName}`, `🔁 RECOVERY SUCCESS (attempt ${attemptNumber}): ${description} -> ${candidate}`);
+                                        // Marcar sucesso no Hub com número da tentativa
+                                        try {
+                                            const sessionId = TestContext.getOrCreateSessionId();
+                                            await markSuccess(sessionId, attemptNumber);
+                                        }
+                                        catch { }
+                                        // Report success com logId (v2.7.44)
+                                        try {
+                                            await reportResult({
+                                                logId,
+                                                sessionId: TestContext.getOrCreateSessionId(),
+                                                xpath: candidate,
+                                                attemptNumber,
+                                                success: true,
+                                                autoFixed: false,
+                                                recoverySource: "framework",
+                                                executionSource: recoveryMeta.executionSource,
+                                                testCaseName: recoveryMeta.testCaseName,
+                                                testCaseId: recoveryMeta.testCaseId,
+                                                testMethodName: recoveryMeta.testMethodName,
+                                            });
+                                        }
+                                        catch { }
+                                        // Auto-fix local se confiança >= 0.7 e autoFixAvailable (v2.7.44)
+                                        if (!response.analysis?.autoFixAvailable) {
+                                            Logger.info(`[ActionInterceptor] AutoFix não disponível (autoFixAvailable=${response.analysis?.autoFixAvailable}, executionSource=${recoveryMeta.executionSource})`);
+                                        }
+                                        if (response.analysis?.autoFixAvailable &&
+                                            confidence >= 0.7) {
+                                            Logger.info(`[ActionInterceptor] 🛠️ AutoFix: iniciando correção local "${failedXPath}" → "${candidate}"`);
+                                            try {
+                                                const { testRecoveryHelper } = await import("./testRecovery/TestRecoveryClient.js");
+                                                const projRoot = testRecoveryHelper.getProjectRoot() ||
+                                                    process.env.AUTOCORE_PROJECT_ROOT ||
+                                                    process.cwd();
+                                                // Enriquecer auto-fix com contexto de Attributes/Page (item 7/12 v2.7.44)
+                                                let attrCtx = {};
+                                                try {
+                                                    const { WebActions } = await import("../playwright/WebActions.js");
+                                                    attrCtx = WebActions.getCallerAttributesContext();
+                                                }
+                                                catch { }
+                                                const resolvedMethodName = attrCtx.methodName || recoveryMeta.testMethodName;
+                                                let autoFixConfirmed = false;
+                                                // 1) MCP local-first (preferencial)
+                                                try {
+                                                    const { fixXPathViaLocalMcp } = await import("./McpLocalClient.js");
+                                                    const mcpFix = await fixXPathViaLocalMcp({
+                                                        projectRoot: projRoot,
+                                                        oldXPath: failedXPath,
+                                                        newXPath: candidate,
+                                                        confidence,
+                                                        className: attrCtx.className,
+                                                        attributesFile: attrCtx.attributesFile,
+                                                        methodName: resolvedMethodName,
+                                                        executionSource: "Local",
+                                                    });
+                                                    autoFixConfirmed = !!(mcpFix?.success && mcpFix.fileUpdated !== false);
+                                                }
+                                                catch (mcpFixError) {
+                                                    Logger.warning(`[ActionInterceptor] Auto-fix via MCP local falhou: ${mcpFixError instanceof Error ? mcpFixError.message : String(mcpFixError)}`);
+                                                }
+                                                // 2) Fallback HTTP auto-fix-local quando MCP local não confirmou escrita
+                                                if (!autoFixConfirmed) {
+                                                    const apiFix = await testRecoveryHelper.autoFixLocal({
+                                                        projectRoot: projRoot,
+                                                        oldXPath: failedXPath,
+                                                        newXPath: candidate,
+                                                        confidence,
+                                                        methodName: resolvedMethodName,
+                                                        executionSource: "Local",
+                                                        className: attrCtx.className,
+                                                        attributesFile: attrCtx.attributesFile,
+                                                    });
+                                                    autoFixConfirmed = !!(apiFix.success && apiFix.fix?.filePath);
+                                                    if (!autoFixConfirmed) {
+                                                        Logger.warning(`[ActionInterceptor] Auto-fix não confirmou escrita local para ${failedXPath} -> ${candidate}`);
+                                                    }
+                                                }
+                                                if (autoFixConfirmed) {
+                                                    try {
+                                                        await reportResult({
+                                                            logId,
+                                                            sessionId: TestContext.getOrCreateSessionId(),
+                                                            xpath: candidate,
+                                                            attemptNumber,
+                                                            success: true,
+                                                            autoFixed: true,
+                                                            recoverySource: "framework",
+                                                            executionSource: recoveryMeta.executionSource,
+                                                            testCaseName: recoveryMeta.testCaseName,
+                                                            testCaseId: recoveryMeta.testCaseId,
+                                                            testMethodName: recoveryMeta.testMethodName,
+                                                        });
+                                                    }
+                                                    catch { }
+                                                }
+                                            }
+                                            catch { }
+                                        }
+                                        return retryResult;
+                                    }
+                                    catch (retryErr) {
+                                        // continuar para próximo candidato/attempt
+                                        continue;
+                                    }
+                                }
+                                // Reportar falha após esgotar tentativas (v2.7.44)
+                                await frameHelper.switchToDefaultIfNeeded();
+                                try {
+                                    await reportResult({
+                                        logId,
+                                        sessionId: TestContext.getOrCreateSessionId(),
+                                        xpath: suggestedXPath,
+                                        attemptNumber: attemptNumber - 1,
+                                        success: false,
+                                        recoverySource: "framework",
+                                        executionSource: recoveryMeta.executionSource,
+                                        testCaseName: recoveryMeta.testCaseName,
+                                        testCaseId: recoveryMeta.testCaseId,
+                                        testMethodName: recoveryMeta.testMethodName,
+                                    });
+                                }
+                                catch { }
+                            }
+                        }
+                    }
+                }
+                catch (recoveryErr) {
+                    Logger.warning(`[ActionInterceptor] ⚠️ AutoHealing falhou: ${recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr)}`);
+                }
+                throw error;
+            }
+        };
+        ActionInterceptor.interceptedMethods.add(key);
+    }
+    /**
+     * ✅ Gera descrição amigável da ação
+     */
+    static generateActionDescription(methodName, args, actionType) {
+        try {
+            switch (actionType) {
+                case "Web":
+                    return ActionInterceptor.generateWebDescription(methodName, args);
+                case "Mobile":
+                    return ActionInterceptor.generateMobileDescription(methodName, args);
+                case "API":
+                    return ActionInterceptor.generateApiDescription(methodName, args);
+                default:
+                    return `${methodName} com ${args.length} parâmetros`;
+            }
+        }
+        catch {
+            return `${methodName} executado`;
+        }
+    }
+    /**
+     * ✅ Gera descrição para ações Web
+     */
+    static generateWebDescription(methodName, args) {
+        const [selector, value, description] = args;
+        const element = ActionInterceptor.extractSelector(selector);
+        switch (methodName) {
+            case "click":
+                return description || `Clicar no elemento "${element}"`;
+            case "fill":
+            case "type":
+                return description || `Preencher "${element}" com "${value}"`;
+            case "press":
+                return description || `Pressionar tecla "${value}" em "${element}"`;
+            case "selectOption":
+                return description || `Selecionar opção "${value}" em "${element}"`;
+            case "check":
+                return description || `Marcar checkbox "${element}"`;
+            case "uncheck":
+                return description || `Desmarcar checkbox "${element}"`;
+            case "hover":
+                return description || `Passar mouse sobre "${element}"`;
+            case "navigate":
+                return description || `Navegar para "${selector}"`;
+            case "waitForElement":
+                return description || `Aguardar elemento "${element}"`;
+            case "waitForText":
+                return description || `Aguardar texto "${value}" em "${element}"`;
+            default:
+                return description || `Executar ${methodName} em "${element}"`;
+        }
+    }
+    /**
+     * ✅ Gera descrição para ações Mobile
+     */
+    static generateMobileDescription(methodName, args) {
+        const [selector, value, description] = args;
+        const element = ActionInterceptor.extractSelector(selector);
+        switch (methodName) {
+            case "click":
+            case "tap":
+                return description || `Tocar no elemento "${element}"`;
+            case "setText":
+                return description || `Inserir texto "${value}" em "${element}"`;
+            case "swipe":
+                return description || `Deslizar de ${args[0]} para ${args[1]}`;
+            case "scroll":
+                return description || `Rolar tela ${args[0] || "para baixo"}`;
+            case "waitForElement":
+                return description || `Aguardar elemento "${element}"`;
+            default:
+                return description || `Executar ${methodName} no mobile`;
+        }
+    }
+    /**
+     * ✅ Gera descrição para ações API
+     */
+    static generateApiDescription(methodName, args) {
+        const [url, data, description] = args;
+        switch (methodName) {
+            case "get":
+                return description || `Requisição GET para "${url}"`;
+            case "post":
+                return description || `Requisição POST para "${url}"`;
+            case "put":
+                return description || `Requisição PUT para "${url}"`;
+            case "delete":
+                return description || `Requisição DELETE para "${url}"`;
+            case "patch":
+                return description || `Requisição PATCH para "${url}"`;
+            case "request":
+                return description || `Requisição HTTP para "${url}"`;
+            default:
+                return description || `Requisição ${methodName} executada`;
+        }
+    }
+    /**
+     * ✅ Extrai seletor de diferentes tipos
+     */
+    static extractSelector(selector) {
+        if (typeof selector === "string") {
+            return selector;
+        }
+        if (selector && typeof selector === "object") {
+            // Playwright Locator
+            if (selector._selector)
+                return selector._selector;
+            if (selector.selector)
+                return selector.selector;
+            // Mobile selector
+            if (selector.using && selector.value) {
+                return `${selector.using}="${selector.value}"`;
+            }
+        }
+        return String(selector).substring(0, 50) + "...";
+    }
+    /**
+     * ✅ Força o refresh da página
+     */
+    static async forceRefresh() {
+        try {
+            if (TestContext.isPageInitialized()) {
+                const page = TestContext.getPage();
+                // Tentar recarregar a página com Playwright
+                await page.reload({ waitUntil: "networkidle" });
+                // Fallback: Forçar refresh com JavaScript (cache-busting)
+                await page.evaluate(() => {
+                    location.reload();
+                });
+            }
+        }
+        catch (error) {
+            console.error("Erro ao tentar forçar o refresh da página:", error);
+        }
+    }
+}
+// ✅ Auto-inicialização
+ActionInterceptor.initialize();