@silasfmartins/testhub 1.0.0

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

@@ -0,0 +1,17 @@
+/**
+ * Teams Relay Flush Hook (v2.7.44 - item 13)
+ *
+ * Garante envio de notificações Teams pela rede da máquina que executou o framework.
+ * Deve ser chamado em `finally` (passou/falhou) ao final de cada execução.
+ * Não bloqueia o resultado do teste por falha de flush.
+ */
+/**
+ * Tenta enviar flush de notificações Teams via MCP local.
+ *
+ * - Chama o backend para consumir fila pendente e envia via rede local.
+ * - Retry curto (3 tentativas com backoff).
+ * - Não bloqueia o resultado do teste.
+ *
+ * @param limit Número máximo de itens a processar (default: 50)
+ */
+export declare function teamsFlushAfterExecution(limit?: number): Promise<void>;

package/dist/src/utils/TeamsFlushHook.js

@@ -0,0 +1,168 @@
+/**
+ * Teams Relay Flush Hook (v2.7.44 - item 13)
+ *
+ * Garante envio de notificações Teams pela rede da máquina que executou o framework.
+ * Deve ser chamado em `finally` (passou/falhou) ao final de cada execução.
+ * Não bloqueia o resultado do teste por falha de flush.
+ */
+import { Logger } from './Logger.js';
+const FLUSH_MAX_RETRIES = 3;
+const FLUSH_BACKOFF_BASE_MS = 1000;
+/**
+ * Tenta enviar flush de notificações Teams via MCP local.
+ *
+ * - Chama o backend para consumir fila pendente e envia via rede local.
+ * - Retry curto (3 tentativas com backoff).
+ * - Não bloqueia o resultado do teste.
+ *
+ * @param limit Número máximo de itens a processar (default: 50)
+ */
+export async function teamsFlushAfterExecution(limit = 50) {
+    // Verificar se flush está habilitado
+    if (process.env.HUB_TEAMS_FLUSH_ENABLED === 'false') {
+        return;
+    }
+    const backendUrl = process.env.HUB_BACKEND_URL || process.env.AUTOCORE_HUB_URL || '';
+    if (!backendUrl) {
+        Logger.warning('[TeamsFlush] HUB_BACKEND_URL não configurado, flush ignorado.');
+        return;
+    }
+    const mcpKey = process.env.HUB_MCP_KEY || process.env.MCP_INTERNAL_KEY || process.env.TEAMS_RELAY_KEY || '';
+    const userHash = process.env.HUB_MCP_USER_HASH || '';
+    for (let attempt = 1; attempt <= FLUSH_MAX_RETRIES; attempt++) {
+        try {
+            const result = await executeFlush(backendUrl, limit, mcpKey, userHash);
+            if (result) {
+                const { fetched = 0, sent = 0, failed = 0, skipped = 0 } = result;
+                Logger.info(`[TeamsFlush] Flush concluído: fetched=${fetched}, sent=${sent}, failed=${failed}, skipped=${skipped}`);
+            }
+            return;
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            if (attempt < FLUSH_MAX_RETRIES) {
+                const delay = FLUSH_BACKOFF_BASE_MS * attempt;
+                Logger.warning(`[TeamsFlush] Tentativa ${attempt}/${FLUSH_MAX_RETRIES} falhou: ${errorMsg}. Retentando em ${delay}ms...`);
+                await new Promise(r => setTimeout(r, delay));
+            }
+            else {
+                Logger.warning(`[TeamsFlush] Todas as ${FLUSH_MAX_RETRIES} tentativas falharam: ${errorMsg}`);
+                // Fallback: tentar MCP local quando backend falhou (item 13 v2.7.44)
+                try {
+                    const localResult = await executeFlushViaMcpLocal(limit);
+                    if (localResult) {
+                        const { fetched = 0, sent = 0, failed = 0, skipped = 0 } = localResult;
+                        Logger.info(`[TeamsFlush] Fallback MCP local concluído: fetched=${fetched}, sent=${sent}, failed=${failed}, skipped=${skipped}`);
+                        return;
+                    }
+                }
+                catch (localErr) {
+                    Logger.warning(`[TeamsFlush] Fallback MCP local também falhou: ${localErr instanceof Error ? localErr.message : String(localErr)}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * Fallback: flush via MCP local (item 13 v2.7.44).
+ * Ordem: STDIO direto → HTTP MCP local.
+ * Usado quando backend direto não está acessível (firewall/proxy).
+ */
+async function executeFlushViaMcpLocal(limit) {
+    // 1) Tentar via STDIO direto (McpLocalClient — item 13 + 27.1)
+    try {
+        const { callMcpToolLocalFirst } = await import('./McpLocalClient.js');
+        const result = await callMcpToolLocalFirst('teams_flush', { limit, dispatchMode: 'local' });
+        if (result?.result && typeof result.result === 'object') {
+            return result.result;
+        }
+    }
+    catch {
+        // STDIO indisponível, tentar HTTP
+    }
+    // 2) Fallback: HTTP MCP local
+    const mcpLocalUrl = process.env.HUB_MCP_LOCAL_URL || 'http://brtlvlty0559pl:3333';
+    const userHash = process.env.HUB_MCP_USER_HASH || process.env.MCP_USER_HASH || '';
+    const reqBody = {
+        jsonrpc: '2.0',
+        id: `teams-flush-${Date.now()}`,
+        method: 'tools/call',
+        params: {
+            name: 'teams_flush',
+            arguments: { limit, dispatchMode: 'local' },
+        },
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 30_000);
+    try {
+        // Construir URL com user_hash como query parameter (item 25.1)
+        let url = `${mcpLocalUrl}/mcp`;
+        if (userHash) {
+            url += `?user_hash=${encodeURIComponent(userHash)}`;
+        }
+        // Construir headers com user_hash
+        const headers = { 'Content-Type': 'application/json' };
+        if (userHash) {
+            headers['x-user-hash'] = userHash;
+        }
+        const res = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(reqBody),
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data.result || null;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+async function executeFlush(backendUrl, limit, mcpKey, userHash) {
+    // Tentar via endpoint direto do backend (flush handler)
+    const url = `${backendUrl.replace(/\/$/, '')}/api/mcp/teams/flush`;
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (mcpKey)
+        headers['x-mcp-key'] = mcpKey;
+    if (userHash)
+        headers['x-mcp-user-hash'] = userHash;
+    const ignoreSSL = process.env.HUB_TEAMS_FLUSH_IGNORE_SSL === 'true';
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 30000);
+    try {
+        // Se precisa ignorar SSL e estiver em Node.js (não browser)
+        const fetchOptions = {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ limit }),
+            signal: controller.signal,
+        };
+        // Para ignorar SSL em Node 18+, usar agent com rejectUnauthorized
+        if (ignoreSSL) {
+            try {
+                const https = await import('node:https');
+                const http = await import('node:http');
+                const agent = url.startsWith('https')
+                    ? new https.Agent({ rejectUnauthorized: false })
+                    : new http.Agent();
+                fetchOptions.agent = agent;
+            }
+            catch {
+                // Se não conseguir criar agent, prosseguir sem ele
+            }
+        }
+        const res = await fetch(url, fetchOptions);
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            throw new Error(`HTTP ${res.status}: ${text}`);
+        }
+        return (await res.json());
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}

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

@@ -0,0 +1,158 @@
+/**
+ * 📋 Sistema de Captura Completa de Logs do Terminal
+ * @description Captura TODOS os logs (console.log, Logger, etc.) que aparecem no terminal
+ * @author AutoCore Team
+ * @version 1.1.0
+ * 🔧 ATUALIZAÇÃO: Logs são persistidos em arquivo para compartilhar entre workers do Playwright
+ */
+/**
+ * 📝 Estrutura de um log capturado
+ */
+export interface CapturedLog {
+    timestamp: string;
+    level: 'log' | 'info' | 'warn' | 'error' | 'debug';
+    message: string;
+    testName?: string;
+    stackTrace?: string;
+    index?: number;
+    workerId?: string;
+    ctName?: string;
+}
+type LogListener = (log: CapturedLog) => void;
+/**
+ * 📊 Sistema de captura de logs do terminal
+ * 🔧 NOTA: Cada worker do Playwright tem sua própria instância em memória,
+ * mas os logs são persistidos em arquivo para compartilhamento.
+ */
+export declare class TerminalLogCapture {
+    private static isActive;
+    private static logs;
+    private static logsByTest;
+    private static currentTestName;
+    private static currentCTName;
+    private static workerId;
+    private static globalLogIndex;
+    private static logListeners;
+    private static originalConsole;
+    private static isCapturing;
+    /**
+     * 🆕 Gera um ID único para este worker
+     */
+    private static generateWorkerId;
+    /**
+     * 🚀 Inicia captura de logs
+     */
+    static start(): void;
+    /**
+     * 🔄 Sincroniza índice global com arquivo existente
+     */
+    private static syncGlobalIndex;
+    /**
+     * 📝 Captura um log
+     * 🔧 ATUALIZADO: Persiste logs em arquivo JSON compartilhado entre workers
+     */
+    private static captureLog;
+    /**
+     * 🆕 Persiste log no arquivo JSON compartilhado entre workers
+     */
+    private static persistLogToSharedFile;
+    /**
+     * 🆕 Escreve arquivo com retry para evitar conflitos
+     */
+    private static writeWithRetry;
+    /**
+     * 🆕 Obtém todos os logs do arquivo compartilhado (para uso cross-worker)
+     */
+    static getSharedLogs(): CapturedLog[];
+    /**
+     * 🆕 Obtém índice global atual do arquivo compartilhado
+     */
+    static getSharedGlobalIndex(): number;
+    /**
+     * 🆕 Obtém o índice global atual em memória (sem acessar arquivo)
+     */
+    static getCurrentGlobalIndex(): number;
+    /**
+     * 🆕 Registra listener para receber logs em tempo real (usado pelos CTs)
+     */
+    static addListener(id: string, listener: LogListener): void;
+    /**
+     * 🆕 Remove listener registrado
+     */
+    static removeListener(id: string): void;
+    private static notifyListeners;
+    /**
+     * 🆕 Limpa arquivo de logs compartilhado (usar no início de nova execução)
+     */
+    static clearSharedLogs(): void;
+    /**
+     * 🔄 Define o teste atual
+     */
+    static setCurrentTest(testName: string): void;
+    /**
+     * 🏁 Limpa o teste atual
+     */
+    static clearCurrentTest(): void;
+    /**
+     * 🆕 Define o CT atual (para filtros mais precisos)
+     */
+    static setCurrentCT(ctName: string): void;
+    /**
+     * 🆕 Limpa o CT atual
+     */
+    static clearCurrentCT(): void;
+    /**
+     * 🆕 Obtém o worker ID atual
+     */
+    static getWorkerId(): string;
+    /**
+     * 🆕 Obtém logs filtrados por CT name (funciona em single e multi-worker)
+     */
+    static getLogsForCT(ctName: string, testName?: string): CapturedLog[];
+    /**
+     * 🆕 Obtém todos os logs combinando memória e arquivo compartilhado (para multi-worker)
+     */
+    static getAllLogsCombined(): CapturedLog[];
+    /**
+     * 🆕 Obtém logs por range de índice (funciona em single e multi-worker)
+     */
+    static getLogsByIndexRange(startIndex: number, endIndex?: number): CapturedLog[];
+    /**
+     * 📊 Retorna todos os logs capturados
+     */
+    static getAllLogs(): CapturedLog[];
+    /**
+     * 📋 Retorna logs de um teste específico
+     */
+    static getLogsForTest(testName: string): CapturedLog[];
+    /**
+     * 📊 Retorna todos os logs organizados por teste
+     */
+    static getLogsByTest(): Map<string, CapturedLog[]>;
+    /**
+     * 💾 Salva logs em arquivo JSON
+     */
+    static saveToFile(outputPath?: string): void;
+    /**
+     * 📝 Adiciona log em arquivo em tempo real
+     */
+    private static appendToLogFile;
+    /**
+     * 🛑 Para captura e restaura console original
+     */
+    static stop(): void;
+    /**
+     * 🧹 Limpa todos os logs
+     */
+    static clear(): void;
+    /**
+     * 📊 Estatísticas de logs
+     */
+    static getStats(): {
+        totalLogs: number;
+        byLevel: Record<CapturedLog['level'], number>;
+        byTest: Record<string, number>;
+        testsWithLogs: number;
+    };
+}
+export {};