@silasfmartins/testhub 1.0.0

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

@@ -0,0 +1,43 @@
+/**
+ * ArtifactsCompressor: Compacta e converte relatórios para Base64
+ * Usado para enviar playwright-report e test-results para o Hub
+ */
+export interface ArtifactsPayload {
+    htmlReport?: string;
+    testResults?: string;
+    traces?: string[];
+    screenshots?: string[];
+    size: {
+        htmlReportBytes: number;
+        testResultsBytes: number;
+        totalBytes: number;
+    };
+}
+export declare class ArtifactsCompressor {
+    private workingDir;
+    constructor(workingDir?: string);
+    /**
+     * 📦 Compacta e converte todos os artifacts para Base64
+     */
+    compressAllArtifacts(): Promise<ArtifactsPayload>;
+    /**
+     * 🗜️ Compacta um diretório em ZIP
+     */
+    private zipDirectory;
+    /**
+     * 📄 Converte arquivo para Base64
+     */
+    private fileToBase64;
+    /**
+     * 🔍 Coleta traces do test-results/
+     */
+    private collectTraces;
+    /**
+     * 📸 Coleta screenshots
+     */
+    private collectScreenshots;
+    /**
+     * 📏 Formata bytes para leitura humana
+     */
+    private formatBytes;
+}

package/dist/src/utils/ArtifactsCompressor.js

@@ -0,0 +1,181 @@
+/**
+ * ArtifactsCompressor: Compacta e converte relatórios para Base64
+ * Usado para enviar playwright-report e test-results para o Hub
+ */
+import { exec } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { promisify } from 'node:util';
+import { Logger } from './Logger.js';
+const execAsync = promisify(exec);
+export class ArtifactsCompressor {
+    workingDir;
+    constructor(workingDir = process.cwd()) {
+        this.workingDir = workingDir;
+    }
+    /**
+     * 📦 Compacta e converte todos os artifacts para Base64
+     */
+    async compressAllArtifacts() {
+        const payload = {
+            size: {
+                htmlReportBytes: 0,
+                testResultsBytes: 0,
+                totalBytes: 0,
+            },
+        };
+        // 1. Compactar playwright-report/
+        const htmlReportPath = path.join(this.workingDir, 'playwright-report');
+        if (fs.existsSync(htmlReportPath)) {
+            const zipPath = await this.zipDirectory(htmlReportPath, 'playwright-report.zip');
+            const base64 = await this.fileToBase64(zipPath);
+            payload.htmlReport = base64;
+            payload.size.htmlReportBytes = Buffer.byteLength(base64, 'base64');
+            // Limpar ZIP temporário
+            fs.unlinkSync(zipPath);
+        }
+        else {
+            Logger.info('   ⚠️ playwright-report/ não encontrado');
+        }
+        // 2. Compactar test-results/
+        const testResultsPath = path.join(this.workingDir, 'test-results');
+        if (fs.existsSync(testResultsPath)) {
+            const zipPath = await this.zipDirectory(testResultsPath, 'test-results.zip');
+            const base64 = await this.fileToBase64(zipPath);
+            payload.testResults = base64;
+            payload.size.testResultsBytes = Buffer.byteLength(base64, 'base64');
+            // Limpar ZIP temporário
+            fs.unlinkSync(zipPath);
+            Logger.info(`   ✅ test-results.zip: ${this.formatBytes(payload.size.testResultsBytes)}`);
+        }
+        else {
+            Logger.info('   ⚠️ test-results/ não encontrado');
+        }
+        // 3. Coletar traces individuais (já estão em ZIP)
+        payload.traces = await this.collectTraces();
+        if (payload.traces.length > 0) {
+            Logger.info(`   ✅ ${payload.traces.length} trace(s) coletado(s)`);
+        }
+        // 4. Coletar screenshots
+        payload.screenshots = await this.collectScreenshots();
+        if (payload.screenshots.length > 0) {
+            Logger.info(`   ✅ ${payload.screenshots.length} screenshot(s) coletado(s)`);
+        }
+        // Calcular tamanho total
+        payload.size.totalBytes =
+            payload.size.htmlReportBytes + payload.size.testResultsBytes;
+        Logger.info(`\n📊 Tamanho total dos artifacts: ${this.formatBytes(payload.size.totalBytes)}`);
+        return payload;
+    }
+    /**
+     * 🗜️ Compacta um diretório em ZIP
+     */
+    async zipDirectory(sourceDir, outputName) {
+        const outputPath = path.join(this.workingDir, outputName);
+        // Detectar OS e usar comando apropriado
+        const isWindows = process.platform === 'win32';
+        try {
+            if (isWindows) {
+                // Windows: usar PowerShell Compress-Archive
+                const psCommand = `Compress-Archive -Path "${sourceDir}\\*" -DestinationPath "${outputPath}" -Force`;
+                await execAsync(psCommand, { shell: 'powershell.exe' });
+            }
+            else {
+                // Linux/Mac: usar zip
+                await execAsync(`cd "${path.dirname(sourceDir)}" && zip -r "${outputPath}" "${path.basename(sourceDir)}"`);
+            }
+            return outputPath;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            Logger.error(`❌ Erro ao compactar ${sourceDir}: ${msg}`);
+            throw error;
+        }
+    }
+    /**
+     * 📄 Converte arquivo para Base64
+     */
+    async fileToBase64(filePath) {
+        try {
+            const fileBuffer = fs.readFileSync(filePath);
+            return fileBuffer.toString('base64');
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            Logger.error(`❌ Erro ao converter ${filePath} para Base64: ${msg}`);
+            throw error;
+        }
+    }
+    /**
+     * 🔍 Coleta traces do test-results/
+     */
+    async collectTraces() {
+        const traces = [];
+        const testResultsPath = path.join(this.workingDir, 'test-results');
+        if (!fs.existsSync(testResultsPath)) {
+            return traces;
+        }
+        try {
+            const dirs = fs.readdirSync(testResultsPath, { withFileTypes: true });
+            for (const dir of dirs) {
+                if (dir.isDirectory()) {
+                    const tracePath = path.join(testResultsPath, dir.name, 'trace.zip');
+                    if (fs.existsSync(tracePath)) {
+                        // Converter trace para Base64
+                        const base64 = await this.fileToBase64(tracePath);
+                        traces.push(base64);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            Logger.warning(`⚠️ Erro ao coletar traces: ${msg}`);
+        }
+        return traces;
+    }
+    /**
+     * 📸 Coleta screenshots
+     */
+    async collectScreenshots() {
+        const screenshots = [];
+        const testResultsPath = path.join(this.workingDir, 'test-results');
+        if (!fs.existsSync(testResultsPath)) {
+            return screenshots;
+        }
+        try {
+            const dirs = fs.readdirSync(testResultsPath, { withFileTypes: true });
+            for (const dir of dirs) {
+                if (dir.isDirectory()) {
+                    const dirPath = path.join(testResultsPath, dir.name);
+                    const files = fs.readdirSync(dirPath);
+                    for (const file of files) {
+                        if (file.endsWith('.png') ||
+                            file.endsWith('.jpg') ||
+                            file.endsWith('.jpeg')) {
+                            const screenshotPath = path.join(dirPath, file);
+                            const base64 = await this.fileToBase64(screenshotPath);
+                            screenshots.push(base64);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            Logger.warning(`⚠️ Erro ao coletar screenshots: ${msg}`);
+        }
+        return screenshots;
+    }
+    /**
+     * 📏 Formata bytes para leitura humana
+     */
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 Bytes';
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return `${Math.round((bytes / k ** i) * 100) / 100} ${sizes[i]}`;
+    }
+}

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

@@ -0,0 +1,47 @@
+/**
+ * 🎯 SOLUÇÃO FINAL: Sistema AutoLogs Completo
+ *
+ * Esta é a implementação definitiva que funcionará perfeitamente
+ * com a sintaxe original do usuário.
+ */
+/**
+ * 🔥 AutoLogsFinal - Sistema definitivo e funcional
+ */
+export declare class AutoLogsFinal {
+    private static ativo;
+    private static originalNew;
+    /**
+     * 🚀 Ativar sistema de logs automáticos
+     */
+    static ativar(): void;
+    /**
+     * 🌐 Interceptação total e eficaz
+     */
+    private static interceptarTotalmenre;
+    /**
+     * 🎨 Interceptar protótipos diretamente
+     */
+    private static interceptarPrototipos;
+    /**
+     * 🎨 Aplicar logs a uma instância
+     */
+    static aplicarLogs<T extends object>(instance: T): T;
+    /**
+     * 🛑 Desativar sistema
+     */
+    static desativar(): void;
+    /**
+     * 📊 Status do sistema
+     */
+    static status(): {
+        ativo: boolean;
+    };
+}
+/**
+ * 🌟 Função para usar em qualquer lugar
+ */
+export declare function aplicarAutoLogsEm<T extends object>(instance: T): T;
+/**
+ * 🔥 Função principal para ativar
+ */
+export declare function ativarAutoLogsFinal(): void;

package/dist/src/utils/AutoLogsFinal.js

@@ -0,0 +1,148 @@
+/**
+ * 🎯 SOLUÇÃO FINAL: Sistema AutoLogs Completo
+ *
+ * Esta é a implementação definitiva que funcionará perfeitamente
+ * com a sintaxe original do usuário.
+ */
+import { ConfigLogger } from './ConfigLogger.js';
+/**
+ * 🔥 AutoLogsFinal - Sistema definitivo e funcional
+ */
+export class AutoLogsFinal {
+    static ativo = false;
+    static originalNew = null;
+    /**
+     * 🚀 Ativar sistema de logs automáticos
+     */
+    static ativar() {
+        if (AutoLogsFinal.ativo)
+            return;
+        AutoLogsFinal.ativo = true;
+        ConfigLogger.success('🔥 AutoLogs FINAL ativado - Interceptação total');
+        // Interceptar TODAS as formas de criação de objetos
+        AutoLogsFinal.interceptarTotalmenre();
+    }
+    /**
+     * 🌐 Interceptação total e eficaz
+     */
+    static interceptarTotalmenre() {
+        // 1. Interceptar Object.create
+        const originalCreate = Object.create;
+        Object.create = function (proto, propertiesObject) {
+            const obj = originalCreate.call(this, proto, propertiesObject);
+            if (proto &&
+                proto.constructor &&
+                proto.constructor.name &&
+                proto.constructor.name.startsWith('Statements')) {
+                return AutoLogsFinal.aplicarLogs(obj);
+            }
+            return obj;
+        };
+        // 2. Interceptar new via Proxy em Function.prototype
+        const originalCall = Function.prototype.call;
+        Function.prototype.call = function (thisArg, ...args) {
+            const result = originalCall.call(this, thisArg, ...args);
+            // Se é um constructor e retorna objeto
+            if (this.prototype &&
+                result &&
+                typeof result === 'object' &&
+                this.name &&
+                this.name.startsWith('Statements')) {
+                return AutoLogsFinal.aplicarLogs(result);
+            }
+            return result;
+        };
+        // 3. Interceptar via defineProperty no prototype das classes
+        AutoLogsFinal.interceptarPrototipos();
+    }
+    /**
+     * 🎨 Interceptar protótipos diretamente
+     */
+    static interceptarPrototipos() {
+        // Interceptar quando qualquer propriedade é definida
+        const originalDefineProperty = Object.defineProperty;
+        Object.defineProperty = function (obj, prop, descriptor) {
+            const result = originalDefineProperty.call(this, obj, prop, descriptor);
+            // Se está definindo constructor de uma classe Statements
+            if (prop === 'constructor' &&
+                descriptor.value &&
+                descriptor.value.name &&
+                descriptor.value.name.startsWith('Statements')) {
+                // Interceptar o constructor
+                const originalConstructor = descriptor.value;
+                descriptor.value = (...args) => {
+                    const instance = new originalConstructor(...args);
+                    return AutoLogsFinal.aplicarLogs(instance);
+                };
+                // Manter propriedades do constructor original
+                Object.setPrototypeOf(descriptor.value, originalConstructor);
+                descriptor.value.prototype = originalConstructor.prototype;
+                descriptor.value.name = originalConstructor.name;
+            }
+            return result;
+        };
+    }
+    /**
+     * 🎨 Aplicar logs a uma instância
+     */
+    static aplicarLogs(instance) {
+        if (!AutoLogsFinal.ativo)
+            return instance;
+        const className = instance.constructor.name;
+        return new Proxy(instance, {
+            get(target, prop) {
+                const value = Reflect.get(target, prop);
+                if (typeof value === 'function' &&
+                    typeof prop === 'string' &&
+                    !prop.startsWith('_') &&
+                    prop !== 'constructor') {
+                    return async (...args) => {
+                        const startTime = Date.now();
+                        // Log de início
+                        ConfigLogger.methodStart(prop, className, args);
+                        try {
+                            // Executar método original
+                            const result = await value.apply(target, args);
+                            // Log de sucesso
+                            const duration = Date.now() - startTime;
+                            ConfigLogger.methodEnd(prop, className, true, duration);
+                            return result;
+                        }
+                        catch (error) {
+                            // Log de erro
+                            const duration = Date.now() - startTime;
+                            ConfigLogger.methodEnd(prop, className, false, duration);
+                            ConfigLogger.error(`Erro em ${className}.${prop}`, error);
+                            throw error;
+                        }
+                    };
+                }
+                return value;
+            },
+        });
+    }
+    /**
+     * 🛑 Desativar sistema
+     */
+    static desativar() {
+        AutoLogsFinal.ativo = false;
+    }
+    /**
+     * 📊 Status do sistema
+     */
+    static status() {
+        return { ativo: AutoLogsFinal.ativo };
+    }
+}
+/**
+ * 🌟 Função para usar em qualquer lugar
+ */
+export function aplicarAutoLogsEm(instance) {
+    return AutoLogsFinal.aplicarLogs(instance);
+}
+/**
+ * 🔥 Função principal para ativar
+ */
+export function ativarAutoLogsFinal() {
+    AutoLogsFinal.ativar();
+}

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

@@ -0,0 +1,114 @@
+/**
+ * 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
+ */
+/** Evento capturado pelo recorder (contrato mínimo — item 16) */
+export interface RecordedEvent {
+    action: 'click' | 'fill' | 'select' | 'check' | 'uncheck' | 'press' | 'navigate';
+    selector?: string;
+    xpath?: string;
+    value?: string;
+    pageUrl?: string;
+    pageTitle?: string;
+    timestamp: number;
+}
+/**
+ * Resultado de uma chamada à ferramenta MCP playwright_execute.
+ * O shape real depende do MCP; aqui declaramos os campos usados internamente.
+ */
+export interface PlaywrightExecuteResult {
+    success?: boolean;
+    error?: string;
+    capturedElements?: unknown[];
+    data?: unknown;
+    [key: string]: unknown;
+}
+/** Opções de inicialização da sessão */
+export interface CodeGenSessionOptions {
+    headless?: boolean;
+    ignoreSSL?: boolean;
+    autoLogin?: boolean;
+    systemName?: string;
+    environmentType?: string;
+    /** URL inicial para navegação (navegará automaticamente no start) */
+    startUrl?: string;
+    /** Se true, reinicia sessão mesmo que já exista (item 15/27.5) */
+    fromScratch?: boolean;
+    /** Alias de fromScratch (item 15/27.5) */
+    resetSession?: boolean;
+}
+/** Alvos suportados para geração de código */
+export type CodegenTarget = 'framework' | 'playwright' | 'both';
+/**
+ * Função que executa uma chamada MCP `playwright_execute`.
+ * Deve ser injetada via `CodeGenSession.setTransport()` antes do uso.
+ */
+export type McpTransport = (action: string, params?: Record<string, unknown>) => Promise<PlaywrightExecuteResult>;
+export declare class CodeGenSession {
+    private active;
+    private recording;
+    private recordedEvents;
+    private options;
+    /** Injeta a função de transporte MCP (obrigatório antes de usar) */
+    static setTransport(fn: McpTransport): void;
+    private call;
+    /**
+     * 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).
+     */
+    start(opts?: CodeGenSessionOptions): Promise<PlaywrightExecuteResult>;
+    /**
+     * Executa uma ação na sessão ativa (navigate/click/fill/select/…).
+     */
+    execute(action: string, params?: Record<string, unknown>): Promise<PlaywrightExecuteResult>;
+    /**
+     * Gera preview do código capturado (inspeção).
+     */
+    codegenPreview(): Promise<PlaywrightExecuteResult>;
+    /**
+     * Exporta código capturado (Playwright puro ou framework).
+     */
+    codegenExport(target?: CodegenTarget): Promise<PlaywrightExecuteResult>;
+    /**
+     * Gera código com alvo específico (alias conveniente).
+     */
+    codegen(target?: CodegenTarget): Promise<PlaywrightExecuteResult>;
+    /**
+     * Encerra a sessão. Chamar somente APÓS etapa de codegen.
+     */
+    close(): Promise<void>;
+    /** Verifica se a sessão está ativa */
+    isActive(): boolean;
+    /**
+     * 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.
+     */
+    startRecording(): Promise<void>;
+    /**
+     * Para a gravação e coleta os eventos capturados do browser.
+     * Faz flush para `capturedElements` internamente.
+     */
+    stopRecording(): Promise<RecordedEvent[]>;
+    /** Registra manualmente um evento (para integração programática) */
+    addEvent(event: RecordedEvent): void;
+    /** Retorna todos os eventos gravados */
+    getRecordedEvents(): RecordedEvent[];
+    /** Limpa eventos gravados */
+    clearEvents(): void;
+}