@silasfmartins/testhub 1.0.0

package/dist/src/utils/Logger.js

@@ -0,0 +1,284 @@
+import { TestContext } from '../testContext/TestContext.js';
+import { UnifiedReportManager } from '../testContext/UnifiedReportManager.js';
+import { sanitizeLogMessage } from './LogSanitizer.js';
+export class Logger {
+    static logLevel = process.env.LOG_LEVEL || 'info';
+    static logLevels = {
+        debug: 0,
+        info: 1,
+        warning: 2,
+        error: 3,
+    };
+    /**
+     * Sanitiza uma mensagem antes de logar, mascarando segredos.
+     */
+    static safe(message) {
+        return sanitizeLogMessage(message);
+    }
+    /**
+     * ATUALIZADO: Registra logs de sucesso e integra com UnifiedReportManager
+     */
+    static success(message) {
+        const fullMessage = `✅ ${Logger.safe(message)}`;
+        if (Logger.shouldLog('info'))
+            console.log(fullMessage);
+        // Verificar se testInfo existe e se annotations está disponível
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo &&
+            testInfo.annotations &&
+            Array.isArray(testInfo.annotations)) {
+            testInfo.annotations.push({ type: 'success', description: fullMessage });
+        }
+        // NOVO: Registrar também no UnifiedReportManager se teste ativo
+        if (testInfo?.title) {
+            try {
+                UnifiedReportManager.adicionarLog(testInfo.title, fullMessage);
+            }
+            catch (error) {
+                // Silenciosamente ignorar se UnifiedReportManager não estiver disponível
+            }
+        }
+    }
+    /**
+     * ATUALIZADO: Registra logs informativos e integra com UnifiedReportManager
+     */
+    static info(message) {
+        const fullMessage = `ℹ️  ${Logger.safe(message)}`;
+        if (Logger.shouldLog('info'))
+            console.log(fullMessage);
+        // Verificar se testInfo existe e se annotations está disponível
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo &&
+            testInfo.annotations &&
+            Array.isArray(testInfo.annotations)) {
+            testInfo.annotations.push({ type: 'info', description: fullMessage });
+        }
+        // NOVO: Registrar também no UnifiedReportManager se teste ativo
+        if (testInfo?.title) {
+            try {
+                UnifiedReportManager.adicionarLog(testInfo.title, fullMessage);
+            }
+            catch (error) {
+                // Silenciosamente ignorar se UnifiedReportManager não estiver disponível
+            }
+        }
+    }
+    /**
+     * ATUALIZADO: Registra logs de aviso e integra com UnifiedReportManager
+     */
+    static warning(message) {
+        const fullMessage = `⚠️ ${Logger.safe(message)}`;
+        if (Logger.shouldLog('warning'))
+            console.warn(fullMessage);
+        // Verificar se testInfo existe e se annotations está disponível
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo &&
+            testInfo.annotations &&
+            Array.isArray(testInfo.annotations)) {
+            testInfo.annotations.push({ type: 'warning', description: fullMessage });
+        }
+        // NOVO: Registrar também no UnifiedReportManager se teste ativo
+        if (testInfo?.title) {
+            try {
+                UnifiedReportManager.adicionarLog(testInfo.title, fullMessage);
+            }
+            catch (error) {
+                // Silenciosamente ignorar se UnifiedReportManager não estiver disponível
+            }
+        }
+    }
+    /**
+     * ATUALIZADO: Registra logs de erro e integra com UnifiedReportManager
+     */
+    static error(message, error = null) {
+        const fullMessage = `❌ ${Logger.safe(message)}`;
+        if (Logger.shouldLog('error')) {
+            console.error(fullMessage);
+            if (error instanceof Error)
+                console.error(error);
+        }
+        // Verificar se testInfo existe e se annotations está disponível
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo &&
+            testInfo.annotations &&
+            Array.isArray(testInfo.annotations)) {
+            testInfo.annotations.push({
+                type: 'error',
+                description: `${fullMessage}${error instanceof Error ? `: ${error.message}` : ''}`,
+            });
+        }
+        // NOVO: Registrar também no UnifiedReportManager se teste ativo
+        if (testInfo?.title) {
+            try {
+                const errorDetails = error instanceof Error ? `: ${error.message}` : '';
+                UnifiedReportManager.adicionarLog(testInfo.title, `${fullMessage}${errorDetails}`);
+            }
+            catch (reportError) {
+                // Silenciosamente ignorar se UnifiedReportManager não estiver disponível
+            }
+        }
+    }
+    /**
+     * ATUALIZADO: Captura screenshot integrado com UnifiedReportManager
+     */
+    static async captureScreenshot(page, nome = 'screenshot') {
+        try {
+            // Tentar usar o método do TestContext primeiro
+            const screenshot = await TestContext.captureScreenshot(nome);
+            if (screenshot) {
+                // Salvar screenshot se necessário
+                const testInfo = TestContext.getSafeTestInfo();
+                if (testInfo) {
+                    await testInfo.attach(nome, {
+                        body: screenshot,
+                        contentType: 'image/png',
+                    });
+                    // NOVO: Registrar screenshot no UnifiedReportManager
+                    if (testInfo.title) {
+                        try {
+                            UnifiedReportManager.adicionarLog(testInfo.title, `📸 Screenshot capturado: ${nome}`);
+                            // Atualizar metadata de screenshots
+                            const currentMetadata = UnifiedReportManager.getMetrics().testes.find((t) => t.nome === testInfo.title)?.metadata || {};
+                            UnifiedReportManager.setTestMetadata(testInfo.title, {
+                                ...currentMetadata,
+                                screenshots: (currentMetadata.screenshots || 0) + 1,
+                            });
+                        }
+                        catch (error) {
+                            // Silenciosamente ignorar se UnifiedReportManager não estiver disponível
+                        }
+                    }
+                }
+                return;
+            }
+            // Fallback para método anterior se disponível
+            if (page && typeof page.screenshot === 'function') {
+                Logger.info(`📸 Fallback: Capturando screenshot via page: ${nome}`);
+                const screenshot = await page.screenshot({
+                    fullPage: true,
+                    type: 'png',
+                });
+                const testInfo = TestContext.getSafeTestInfo();
+                if (testInfo) {
+                    await testInfo.attach(nome, {
+                        body: screenshot,
+                        contentType: 'image/png',
+                    });
+                    // NOVO: Registrar screenshot no UnifiedReportManager
+                    if (testInfo.title) {
+                        try {
+                            UnifiedReportManager.adicionarLog(testInfo.title, `📸 Screenshot capturado via fallback: ${nome}`);
+                        }
+                        catch (error) {
+                            // Silenciosamente ignorar
+                        }
+                    }
+                }
+                Logger.success(`Screenshot capturado via fallback: ${nome}`);
+                return;
+            }
+            Logger.warning('Page não disponível ou não suporta screenshot');
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            Logger.error(`Erro ao capturar screenshot: ${errorMsg}`);
+        }
+    }
+    static shouldLog(level) {
+        const currentLevel = Logger.logLevels[Logger.logLevel] || 1;
+        const messageLevel = Logger.logLevels[level] || 1;
+        return messageLevel >= currentLevel;
+    }
+    static bloco(titulo) {
+        const linha = '='.repeat(80);
+        console.log(`\n${linha}`);
+        console.log(`🧩 ${titulo.toUpperCase()} ${linha.substring(titulo.length + 4)}`);
+    }
+    static object(valor) {
+        if (Logger.shouldLog('debug')) {
+            console.log(JSON.stringify(valor, null, 2));
+        }
+    }
+    /**
+     * NOVO: Log específico para inicialização de teste
+     */
+    static testStart(testName, testType) {
+        const message = `🚀 Iniciando teste: ${testName} (${testType})`;
+        Logger.info(message);
+    }
+    /**
+     * NOVO: Log específico para finalização de teste
+     */
+    static testEnd(testName, testType, duration, success) {
+        const status = success ? 'PASSOU' : 'FALHOU';
+        const emoji = success ? '✅' : '❌';
+        const message = `${emoji} Teste finalizado: ${testName} (${testType}) - ${status} em ${duration.toFixed(2)}s`;
+        if (success) {
+            Logger.success(message);
+        }
+        else {
+            Logger.error(message);
+        }
+    }
+    /**
+     * NOVO: Log específico para ações de UI
+     */
+    static action(action, element, description) {
+        const elementInfo = element ? ` em "${element}"` : '';
+        const descInfo = description ? ` - ${description}` : '';
+        const message = `🎬 Ação: ${action}${elementInfo}${descInfo}`;
+        Logger.info(message);
+    }
+    /**
+     * NOVO: Log específico para validações
+     */
+    static validation(description, success, expected, actual) {
+        const status = success ? 'PASSOU' : 'FALHOU';
+        const emoji = success ? '✅' : '❌';
+        let message = `${emoji} Validação: ${description} - ${status}`;
+        if (!success && expected !== undefined && actual !== undefined) {
+            message += ` (esperado: ${expected}, obtido: ${actual})`;
+        }
+        if (success) {
+            Logger.success(message);
+        }
+        else {
+            Logger.error(message);
+        }
+    }
+    /**
+     * NOVO: Log específico para métricas e performance
+     */
+    static metric(metricName, value, unit = '', context) {
+        const contextInfo = context ? ` [${context}]` : '';
+        const message = `📊 Métrica${contextInfo}: ${metricName} = ${value}${unit}`;
+        Logger.info(message);
+    }
+    /**
+     * NOVO: Log para debug de desenvolvimento
+     */
+    static debug(message, data) {
+        if (Logger.shouldLog('debug')) {
+            console.log(`🐛 DEBUG: ${Logger.safe(message)}`);
+            if (data !== undefined) {
+                console.log(data);
+            }
+        }
+    }
+    /**
+     * NOVO: Log para separadores visuais
+     */
+    static separator(title) {
+        const linha = '─'.repeat(60);
+        if (title) {
+            const titlePadded = ` ${title} `;
+            const padding = Math.max(0, (60 - titlePadded.length) / 2);
+            const leftPad = '─'.repeat(Math.floor(padding));
+            const rightPad = '─'.repeat(Math.ceil(padding));
+            console.log(`${leftPad}${titlePadded}${rightPad}`);
+        }
+        else {
+            console.log(linha);
+        }
+    }
+}

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

@@ -0,0 +1,141 @@
+/**
+ * MCP Local JSON-RPC Client (v2.7.44-r3 — items 22, 26, 27, 28)
+ *
+ * Permite ao framework chamar tools no MCP local (sidecar/background)
+ * via JSON-RPC sobre STDIO ou HTTP, sem depender de GitHub Copilot Chat.
+ *
+ * Transporte (ordem de prioridade — item 26.2):
+ *  1. STDIO direto (`autocore-hub-mcp`) com Content-Length framing (MCP oficial) — caminho principal
+ *  2. HTTP local (`HUB_MCP_LOCAL_URL`) — bridge HTTP explícita
+ *  3. Backend MCP remoto — fallback/control-plane (backend decide reroute local ou fallback)
+ *
+ * Uso principal: `fix_xpath_in_attributes` para auto-fix de XPaths
+ * nos arquivos Attributes* do projeto local após recovery bem-sucedido.
+ */
+export interface FixXPathInAttributesParams {
+    projectRoot: string;
+    oldXPath: string;
+    newXPath: string;
+    attributesFile?: string;
+    className?: string;
+    methodName?: string;
+    confidence?: number;
+    executionSource?: string;
+}
+export interface FixXPathInAttributesResult {
+    success: boolean;
+    filePath?: string;
+    className?: string;
+    methodName?: string;
+    fileUpdated?: boolean;
+    executedOn?: string;
+    localMcpExecuted?: boolean;
+    localMcpRequestId?: string;
+    nextAction?: string;
+    error?: string;
+    proof?: Record<string, unknown>;
+}
+export interface PortalSavedTestsParams extends Record<string, unknown> {
+    limit?: number;
+    executionId?: string;
+    systemName?: string;
+    environment?: string;
+    includeCode?: boolean;
+}
+export interface PortalSavedTestFile {
+    path: string;
+    language?: string;
+    code: string;
+    [key: string]: unknown;
+}
+export interface PortalSavedTestCt {
+    id?: string;
+    ctName: string;
+    status?: string;
+    type?: string;
+    environment?: string;
+    runScript?: string;
+    runCommand?: string;
+    [key: string]: unknown;
+}
+export interface PortalSavedTestScenario {
+    id: string;
+    scenarioId?: string;
+    scenarioName: string;
+    systemId?: string | null;
+    systemName?: string | null;
+    environment?: string | null;
+    status?: string;
+    cts?: PortalSavedTestCt[];
+    files?: PortalSavedTestFile[];
+    runCommands?: string[];
+    retention?: {
+        days?: number;
+        expiresAt?: string;
+    };
+    [key: string]: unknown;
+}
+export interface PortalSavedTestsResult {
+    total: number;
+    includeCode?: boolean;
+    retentionDays?: number;
+    message?: string;
+    portalTests: PortalSavedTestScenario[];
+    [key: string]: unknown;
+}
+export interface RunLocalNpmScriptParams extends Record<string, unknown> {
+    script: string;
+    projectRoot?: string;
+    timeoutMs?: number;
+}
+export interface RunLocalNpmScriptResult {
+    success?: boolean;
+    message?: string;
+    command?: string;
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    [key: string]: unknown;
+}
+/** Transport channel result */
+type TransportChannel = "stdio" | "http-local" | "http-backend";
+/**
+ * Chama `fix_xpath_in_attributes` no MCP local para corrigir XPath em Attributes*.
+ *
+ * Transporte (item 26.2/28.5):
+ *  1. STDIO direto (Content-Length framing) — não requer user_hash (item 28.1)
+ *  2. HTTP local (HUB_MCP_LOCAL_URL) — requer user_hash
+ *  3. Backend MCP remoto (control-plane para reroute local por user_hash)
+ *
+ * - Faz health-check (tools/list) antes de chamar (item 26.3)
+ * - Parse robusto: top-level → content[].text (item 27.2/28.3)
+ * - Dedupe somente após resultado válido (item 28.4)
+ * - Retry curto (2 tentativas) para erros transitórios
+ * - Não bloqueia o teste em caso de falha
+ * - Pula em execução Azure (sem filesystem local)
+ *
+ * @returns Resultado da correção ou null se ignorado/falhou
+ */
+export declare function fixXPathViaLocalMcp(params: FixXPathInAttributesParams): Promise<FixXPathInAttributesResult | null>;
+/**
+ * Chama uma tool MCP (genérica) priorizando MCP local.
+ * Se o backend responder com `requiresLocalMcp=true`, reencaminha automaticamente
+ * para o STDIO local com o mesmo payload.
+ *
+ * Usado para `codegen`/ações Playwright que precisam rodar na máquina do usuário.
+ */
+export declare function callMcpToolLocalFirst(toolName: string, args: Record<string, unknown>): Promise<{
+    result: unknown;
+    channel: TransportChannel;
+} | null>;
+export declare function callMcpToolBackendFirst(toolName: string, args: Record<string, unknown>): Promise<{
+    result: unknown;
+    channel: TransportChannel;
+} | null>;
+export declare function getPortalSavedTests(params?: PortalSavedTestsParams): Promise<PortalSavedTestsResult | null>;
+export declare function runLocalNpmScriptViaMcp(params: RunLocalNpmScriptParams): Promise<RunLocalNpmScriptResult | null>;
+/** Limpa tracker de dedupe (chamar no início de cada execução, se desejado) */
+export declare function clearFixDedupeTracker(): void;
+/** Limpa cache de health-check de tools (útil para testes) */
+export declare function clearToolsListCache(): void;
+export {};