@silasfmartins/testhub 1.0.0

package/dist/src/utils/CodeGenSession.js

@@ -0,0 +1,264 @@
+/**
+ * CodeGen Session Manager (v2.7.44 - items 15 & 16)
+ *
+ * Mantém uma única sessão Playwright MCP por execução de CT para que o
+ * codegen capture todo o fluxo real em vez de "sempre o mesmo código".
+ *
+ * Item 15 – Fluxo contínuo na mesma sessão:
+ *   1. start() → inicia sessão única
+ *   2. execute() → navega/click/fill na mesma sessão
+ *   3. codegenPreview() / codegenExport() → gera artefato
+ *   4. close() → encerra sessão
+ *
+ * Item 16 – Modo recorder (interação manual):
+ *   1. startRecording() → habilita captura de eventos no browser
+ *   2. (usuário interage manualmente na página)
+ *   3. stopRecording() → coleta eventos e converte em capturedElements
+ *   4. codegenExport() → gera código a partir dos eventos gravados
+ */
+import { Logger } from './Logger.js';
+import { callMcpToolLocalFirst } from './McpLocalClient.js';
+let _transport = null;
+// ---------------------------------------------------------------------------
+// CodeGenSession
+// ---------------------------------------------------------------------------
+export class CodeGenSession {
+    active = false;
+    recording = false;
+    recordedEvents = [];
+    options = {};
+    // ---------- Transport ----------
+    /** Injeta a função de transporte MCP (obrigatório antes de usar) */
+    static setTransport(fn) {
+        _transport = fn;
+    }
+    async call(action, params) {
+        if (!_transport) {
+            throw new Error('[CodeGenSession] Transporte MCP não configurado. Chame CodeGenSession.setTransport() antes de usar.');
+        }
+        const result = await _transport(action, params);
+        // (item 27.4) Reroute automático quando backend requer MCP local
+        if (!result.success &&
+            result.requiresLocalMcp === true) {
+            Logger.info(`[CodeGenSession] Backend requer MCP local para action='${action}', reencaminhando...`);
+            const localResult = await callMcpToolLocalFirst('codegen', { action, ...(params || {}) });
+            if (localResult?.result && typeof localResult.result === 'object') {
+                return localResult.result;
+            }
+        }
+        return result;
+    }
+    // ---------- Item 15 — Sessão contínua ----------
+    /**
+     * Inicia (ou reutiliza) uma sessão Playwright MCP.
+     * Não reinicia browser/context/page — preserva `capturedElements`.
+     * Reinicia apenas com `fromScratch=true` ou `resetSession=true` (item 15/27.5).
+     */
+    async start(opts) {
+        const shouldReset = opts?.fromScratch || opts?.resetSession;
+        if (this.active && !shouldReset) {
+            Logger.info('[CodeGenSession] Sessão já ativa, reutilizando (sessionReused=true).');
+            return { success: true };
+        }
+        // Se reset explícito, fechar sessão atual antes de iniciar nova
+        if (this.active && shouldReset) {
+            Logger.info('[CodeGenSession] Reset explícito solicitado, fechando sessão atual...');
+            await this.close();
+        }
+        this.options = opts ?? {};
+        const params = {};
+        if (this.options.headless != null)
+            params.headless = this.options.headless;
+        if (this.options.ignoreSSL)
+            params.ignoreSSL = true;
+        const res = await this.call('start', params);
+        this.active = true;
+        Logger.info('[CodeGenSession] Sessão Playwright MCP iniciada (sessionCreated=true).');
+        // Navegar automaticamente se URL inicial fornecida
+        if (this.options.startUrl) {
+            await this.execute('navigate', { url: this.options.startUrl });
+        }
+        return res;
+    }
+    /**
+     * Executa uma ação na sessão ativa (navigate/click/fill/select/…).
+     */
+    async execute(action, params) {
+        if (!this.active) {
+            await this.start(this.options);
+        }
+        return this.call(action, params);
+    }
+    /**
+     * Gera preview do código capturado (inspeção).
+     */
+    async codegenPreview() {
+        return this.call('codegen_preview');
+    }
+    /**
+     * Exporta código capturado (Playwright puro ou framework).
+     */
+    async codegenExport(target = 'both') {
+        return this.call('codegen_export', { codegenTarget: target });
+    }
+    /**
+     * Gera código com alvo específico (alias conveniente).
+     */
+    async codegen(target = 'both') {
+        return this.call('codegen', { codegenTarget: target });
+    }
+    /**
+     * Encerra a sessão. Chamar somente APÓS etapa de codegen.
+     */
+    async close() {
+        if (!this.active)
+            return;
+        try {
+            await this.call('close');
+        }
+        catch (err) {
+            Logger.warning(`[CodeGenSession] Erro ao fechar sessão: ${err}`);
+        }
+        finally {
+            this.active = false;
+            this.recording = false;
+            this.recordedEvents = [];
+        }
+        Logger.info('[CodeGenSession] Sessão encerrada.');
+    }
+    /** Verifica se a sessão está ativa */
+    isActive() {
+        return this.active;
+    }
+    // ---------- Item 16 — Modo recorder ----------
+    /**
+     * Inicia gravação de eventos de interação manual.
+     * Injeta um listener de eventos na página ativa que captura
+     * click/fill/select/check/uncheck/press.
+     */
+    async startRecording() {
+        if (!this.active)
+            await this.start(this.options);
+        if (this.recording)
+            return;
+        this.recordedEvents = [];
+        this.recording = true;
+        // Injetar script de captura na página via MCP
+        try {
+            await this.call('evaluate', {
+                expression: RECORDER_INJECT_SCRIPT,
+            });
+        }
+        catch {
+            // Se evaluate não for suportado, apenas marcar como recording
+        }
+        Logger.info('[CodeGenSession] Gravação de interações iniciada.');
+    }
+    /**
+     * Para a gravação e coleta os eventos capturados do browser.
+     * Faz flush para `capturedElements` internamente.
+     */
+    async stopRecording() {
+        if (!this.recording)
+            return [];
+        this.recording = false;
+        // Coletar eventos do browser
+        try {
+            const result = await this.call('evaluate', {
+                expression: '(() => { const e = window.__autocore_recorded || []; window.__autocore_recorded = []; return e; })()',
+            });
+            const events = Array.isArray(result.data) ? result.data : [];
+            for (const ev of events) {
+                if (ev && typeof ev === 'object' && 'action' in ev) {
+                    this.recordedEvents.push({
+                        action: ev.action,
+                        selector: ev.selector,
+                        xpath: ev.xpath,
+                        value: ev.value,
+                        pageUrl: ev.pageUrl,
+                        pageTitle: ev.pageTitle,
+                        timestamp: ev.timestamp || Date.now(),
+                    });
+                }
+            }
+        }
+        catch {
+            // Coleta via MCP não disponível — usar eventos já registrados
+        }
+        Logger.info(`[CodeGenSession] Gravação parada. ${this.recordedEvents.length} evento(s) capturado(s).`);
+        return [...this.recordedEvents];
+    }
+    /** Registra manualmente um evento (para integração programática) */
+    addEvent(event) {
+        this.recordedEvents.push(event);
+    }
+    /** Retorna todos os eventos gravados */
+    getRecordedEvents() {
+        return [...this.recordedEvents];
+    }
+    /** Limpa eventos gravados */
+    clearEvents() {
+        this.recordedEvents = [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Script injetado na página para captura de interações (item 16)
+// ---------------------------------------------------------------------------
+const RECORDER_INJECT_SCRIPT = `
+(() => {
+  if (window.__autocore_recorder_active) return;
+  window.__autocore_recorder_active = true;
+  window.__autocore_recorded = window.__autocore_recorded || [];
+
+  const getSelector = (el) => {
+    if (!el || !el.tagName) return '';
+    if (el.id) return '//*[@id="' + el.id + '"]';
+    if (el.getAttribute('data-testid')) return '//*[@data-testid="' + el.getAttribute('data-testid') + '"]';
+    if (el.getAttribute('name')) return '//' + el.tagName.toLowerCase() + '[@name="' + el.getAttribute('name') + '"]';
+    return '';
+  };
+
+  document.addEventListener('click', (e) => {
+    const el = e.target;
+    window.__autocore_recorded.push({
+      action: 'click',
+      selector: getSelector(el),
+      xpath: getSelector(el),
+      value: undefined,
+      pageUrl: location.href,
+      pageTitle: document.title,
+      timestamp: Date.now(),
+    });
+  }, true);
+
+  document.addEventListener('change', (e) => {
+    const el = e.target;
+    const tag = el.tagName && el.tagName.toLowerCase();
+    const action = tag === 'select' ? 'select'
+      : (el.type === 'checkbox' ? (el.checked ? 'check' : 'uncheck') : 'fill');
+    window.__autocore_recorded.push({
+      action,
+      selector: getSelector(el),
+      xpath: getSelector(el),
+      value: el.value || undefined,
+      pageUrl: location.href,
+      pageTitle: document.title,
+      timestamp: Date.now(),
+    });
+  }, true);
+
+  document.addEventListener('keydown', (e) => {
+    if (['Enter', 'Tab', 'Escape'].includes(e.key)) {
+      window.__autocore_recorded.push({
+        action: 'press',
+        selector: getSelector(e.target),
+        xpath: getSelector(e.target),
+        value: e.key,
+        pageUrl: location.href,
+        pageTitle: document.title,
+        timestamp: Date.now(),
+      });
+    }
+  }, true);
+})()
+`;

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

@@ -0,0 +1,133 @@
+/**
+ * Gerenciador de logs de configuração para Playwright
+ * Fornece informações detalhadas sobre configurações e ambiente
+ * ATUALIZADO: Integrado com a nova arquitetura unificada
+ */
+export declare class ConfigLogger {
+    private static logFile;
+    private static projectName;
+    private static logToFile;
+    private static initialized;
+    private static startTime;
+    /**
+     * Inicializa o logger de configurações
+     * @param options Opções de inicialização
+     */
+    static init(options?: {
+        projectName?: string;
+        logToFile?: boolean;
+        logDir?: string;
+    }): void;
+    /**
+     * Obtém o nome do projeto do package.json
+     */
+    private static getProjectNameFromPackageJson;
+    /**
+     * Escreve no arquivo de log
+     */
+    private static appendToLogFile;
+    /**
+     * Registra log informativo
+     */
+    static info(message: string): void;
+    /**
+     * Registra log de sucesso
+     */
+    static success(message: string): void;
+    /**
+     * Registra log de aviso
+     */
+    static warning(message: string): void;
+    /**
+     * Registra log de erro
+     */
+    static error(message: string, error?: any): void;
+    /**
+     * Registra log crítico (erro grave que pode impedir a execução)
+     */
+    static critical(message: string, error?: any): void;
+    /**
+     * Registra resumo da configuração do ambiente
+     */
+    static logEnvironmentConfig(): void;
+    /**
+     * Registra variáveis de ambiente relevantes para o projeto
+     */
+    static logEnvironmentVariables(): void;
+    /**
+     * NOVO: Log específico para variáveis Mobile
+     */
+    private static logMobileVariables;
+    /**
+     * NOVO: Log específico para variáveis SSH
+     */
+    private static logSSHVariables;
+    /**
+     * NOVO: Log específico para variáveis de Banco
+     */
+    private static logDatabaseVariables;
+    /**
+     * Retorna o caminho do arquivo de lock usado para evitar inicialização múltipla
+     */
+    private static getLockFilePath;
+    /**
+     * Verifica se o ConfigLogger já foi executado antes (evita inicialização múltipla)
+     */
+    private static hasRunBefore;
+    /**
+     * Marca o ConfigLogger como já inicializado
+     */
+    private static markAsRun;
+    /**
+     * Limpa o estado e arquivos temporários do ConfigLogger
+     */
+    static cleanup(): void;
+    /**
+     * Registra informações sobre o Playwright (versão otimizada)
+     */
+    static logPlaywrightConfig(): void;
+    /**
+     * Lê e extrai informações do arquivo de configuração do Playwright
+     * sem executar comandos externos (apenas parsing de texto)
+     */
+    private static readPlaywrightConfigFile;
+    /**
+     * Extrai informações de configuração do conteúdo do arquivo usando regex
+     * (parsing simples sem executar código)
+     */
+    private static parseConfigContent;
+    /**
+     * NOVO: Gera relatório de configuração do projeto
+     */
+    static generateProjectReport(): {
+        projectName: string;
+        projectType?: string;
+        environment?: string;
+        configuredFeatures: string[];
+        missingFeatures: string[];
+    };
+    /**
+     * NOVO: Log do relatório de projeto
+     */
+    static logProjectReport(): void;
+    /**
+     * 🚀 Inicia execução de um método com separador visual
+     */
+    static methodStart(methodName: string, className?: string, params?: any[]): void;
+    /**
+     * ✅ Finaliza execução de um método
+     */
+    static methodEnd(methodName: string, className?: string, success?: boolean, duration?: number): void;
+    /**
+     * 📋 Log simples de método com separador pequeno
+     */
+    static methodLog(methodName: string, className?: string): void;
+    /**
+     * 🎯 Log de separação entre grupos de métodos
+     */
+    static sectionSeparator(sectionName: string): void;
+    /**
+     * 📖 Wrapper para executar método com logs automáticos
+     */
+    static executeWithLogs<T>(methodName: string, className: string, method: () => Promise<T> | T, params?: any[]): Promise<T>;
+}