@silasfmartins/testhub 1.0.0

package/dist/src/playwright/network-logs-reporter.d.ts

@@ -0,0 +1,7 @@
+import type { Reporter, FullResult, FullConfig } from '@playwright/test/reporter';
+declare class NetworkLogsReporter implements Reporter {
+    private projectRoot;
+    onBegin(config: FullConfig): void;
+    onEnd(_result: FullResult): Promise<void>;
+}
+export default NetworkLogsReporter;

package/dist/src/playwright/network-logs-reporter.js

@@ -0,0 +1,66 @@
+/**
+ * Reporter customizado que copia os network logs para playwright-report/evidence/
+ * após a geração do relatório HTML
+ *
+ * Fluxo:
+ * 1. Durante o teste: arquivos são salvos em test-results/network-logs/
+ * 2. Após gerar relatório: arquivos são copiados para playwright-report/evidence/network-logs/
+ *
+ * Para usar, adicione ao seu playwright.config.ts:
+ * @example
+ * import { NetworkLogsReporter } from '@silasfmartins/testhub'
+ * export default defineConfig({
+ *   reporter: [['html'], NetworkLogsReporter],
+ * })
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Logger } from '../utils/Logger.js';
+class NetworkLogsReporter {
+    projectRoot = '';
+    onBegin(config) {
+        // Detecta o diretório do projeto a partir do rootDir do config
+        this.projectRoot = config.rootDir;
+        // Se rootDir termina com 'tests', remove para ir ao projeto raiz
+        if (this.projectRoot.endsWith('tests') || this.projectRoot.endsWith('tests/') || this.projectRoot.endsWith('tests\\')) {
+            this.projectRoot = path.dirname(this.projectRoot);
+        }
+    }
+    async onEnd(_result) {
+        // Copia os arquivos de test-results/network-logs/ para playwright-report/evidence/network-logs/
+        // Isso acontece APÓS a geração do relatório HTML
+        const sourceDir = path.join(this.projectRoot, 'test-results', 'network-logs');
+        const destDir = path.join(this.projectRoot, 'playwright-report', 'evidence', 'network-logs');
+        if (!fs.existsSync(sourceDir)) {
+            return;
+        }
+        try {
+            // Cria pasta destino se não existir
+            if (!fs.existsSync(destDir)) {
+                fs.mkdirSync(destDir, { recursive: true });
+            }
+            // Lista arquivos na pasta source
+            const files = fs.readdirSync(sourceDir);
+            if (files.length === 0) {
+                return;
+            }
+            Logger.info('\n═════════════════════════════════════════════════════════════════');
+            Logger.info('📡 [AutoCore] Copiando Network Logs para playwright-report/');
+            Logger.info('═════════════════════════════════════════════════════════════════');
+            let copiedCount = 0;
+            for (const file of files) {
+                const sourcePath = path.join(sourceDir, file);
+                const destPath = path.join(destDir, file);
+                // Copia o arquivo (mantém original em test-results/)
+                fs.copyFileSync(sourcePath, destPath);
+                copiedCount++;
+            }
+            Logger.success(`   ✅ ${copiedCount} arquivo(s) copiado(s) para: ${destDir}`);
+            Logger.info('═════════════════════════════════════════════════════════════════\n');
+        }
+        catch (err) {
+            Logger.error('❌ [AutoCore] Erro ao copiar network logs', err);
+        }
+    }
+}
+export default NetworkLogsReporter;

package/dist/src/playwright/registerRecoveryWrappers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/playwright/registerRecoveryWrappers.js

@@ -0,0 +1,54 @@
+import { WebActions } from './WebActions.js';
+import { Logger } from '../utils/Logger.js';
+// Register wrappers that call WebActions.withRecovery around public static methods
+// This file is imported once during AutoCore initialization to enable global recovery.
+(function registerRecoveryWrappers() {
+    try {
+        const exclude = new Set([
+            'withRecovery',
+            'extractSelector',
+            'detectSelectorType',
+            'getLocatorInContext',
+            'isInFrame',
+            'getCurrentFrameSelector',
+            'resolveWaitVisibilityOptions',
+            'getCallerMethodName',
+            'interceptForAutoDocs',
+            'updateAutoDocsStatus',
+            'getPage',
+            'ensurePageInitialized',
+            'logToUnified',
+            'addActionMetadata',
+            'prototype',
+            'length',
+            'name'
+        ]);
+        const staticNames = Object.getOwnPropertyNames(WebActions);
+        const candidates = staticNames.filter((n) => {
+            if (exclude.has(n))
+                return false;
+            const v = WebActions[n];
+            return typeof v === 'function';
+        });
+        for (const name of candidates) {
+            const orig = WebActions[name];
+            if (!orig || orig.__recovery_wrapped)
+                continue;
+            const wrapped = function (...args) {
+                const originalElement = args.length ? args[0] : undefined;
+                return WebActions.withRecovery(originalElement, name, async (candidate) => {
+                    const newArgs = Array.from(args);
+                    if (newArgs.length)
+                        newArgs[0] = candidate;
+                    return orig.apply(WebActions, newArgs);
+                }, args[1]);
+            };
+            wrapped.__recovery_wrapped = true;
+            WebActions[name] = wrapped;
+        }
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        Logger.warning(`⚠️ [WebActions] Failed to register recovery wrappers: ${e}`);
+    }
+})();

package/dist/src/security/BuildSecurity.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AutoCore Build Security: Watermarking e manifesto assinado
+ * Gera watermarks, hashes e assinatura para validação offline
+ */
+/**
+ * Constrói manifesto completo com assinatura
+ */
+export declare function buildSecurityManifest(distPath: string): void;
+/**
+ * Valida integridade de arquivo específico
+ */
+export declare function validateFileIntegrity(filePath: string, expectedHash: string, expectedWatermark?: string): boolean;

package/dist/src/security/BuildSecurity.js

@@ -0,0 +1,138 @@
+/**
+ * AutoCore Build Security: Watermarking e manifesto assinado
+ * Gera watermarks, hashes e assinatura para validação offline
+ */
+import { createHash, randomBytes } from 'node:crypto';
+import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { extname, join, relative } from 'node:path';
+import { Logger } from '../utils/Logger.js';
+const WATERMARK_SIGNATURE = 'AUTOCORE_WM_';
+const MANIFEST_VERSION = '1.0.0';
+/**
+ * Gera watermark único para arquivo
+ */
+function generateWatermark() {
+    const timestamp = Date.now().toString(36);
+    const random = randomBytes(8).toString('hex');
+    return `${WATERMARK_SIGNATURE}${timestamp}_${random}`;
+}
+/**
+ * Injeta watermark no final do arquivo JS
+ */
+function injectWatermark(filePath) {
+    const content = readFileSync(filePath, 'utf8');
+    const watermark = generateWatermark();
+    // Adiciona watermark como comentário no final
+    const watermarkedContent = `${content}\n// ${watermark}\n`;
+    writeFileSync(filePath, watermarkedContent, 'utf8');
+    return watermark;
+}
+/**
+ * Calcula hash SHA-512 de arquivo
+ */
+function calculateFileHash(filePath) {
+    const content = readFileSync(filePath);
+    return createHash('sha512').update(content).digest('hex');
+}
+/**
+ * Coleta todos os arquivos JS no diretório dist
+ */
+function collectDistFiles(distPath) {
+    const files = [];
+    function scanDir(dir) {
+        const items = readdirSync(dir);
+        for (const item of items) {
+            const fullPath = join(dir, item);
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+                scanDir(fullPath);
+            }
+            else if (extname(item) === '.js') {
+                const relativePath = relative(distPath, fullPath);
+                const watermark = injectWatermark(fullPath);
+                const hash = calculateFileHash(fullPath);
+                files.push({
+                    path: relativePath.replace(/\\/g, '/'), // Normalizar para Unix paths
+                    hash,
+                    size: stat.size,
+                    watermark,
+                });
+            }
+        }
+    }
+    scanDir(distPath);
+    return files;
+}
+/**
+ * Gera manifesto de integridade
+ */
+function generateIntegrityManifest(distPath) {
+    const files = collectDistFiles(distPath);
+    return {
+        version: MANIFEST_VERSION,
+        timestamp: new Date().toISOString(),
+        algo: 'sha512',
+        files,
+    };
+}
+/**
+ * Assina manifesto com chave privada (simulado - use chave real em produção)
+ */
+function signManifest(manifest) {
+    // Em produção, use uma chave privada real
+    // Para este exemplo, geramos uma assinatura determinística
+    const content = JSON.stringify({
+        version: manifest.version,
+        timestamp: manifest.timestamp,
+        files: manifest.files.map((f) => ({ path: f.path, hash: f.hash })),
+    });
+    const hash = createHash('sha256').update(content).digest('hex');
+    return `ECDSA_SIM_${hash.substring(0, 32)}`;
+}
+/**
+ * Constrói manifesto completo com assinatura
+ */
+export function buildSecurityManifest(distPath) {
+    Logger.info('🔒 Gerando manifesto de segurança...');
+    const manifest = generateIntegrityManifest(distPath);
+    manifest.signature = signManifest(manifest);
+    // Salva manifesto principal
+    const manifestPath = join(distPath, 'integrity.manifest.json');
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    // Salva versão compacta para o loader
+    const compactManifest = {
+        v: manifest.version,
+        t: manifest.timestamp,
+        s: manifest.signature,
+        f: manifest.files.map((f) => [f.path, f.hash, f.watermark]),
+    };
+    const compactPath = join(distPath, 'security.compact.json');
+    writeFileSync(compactPath, JSON.stringify(compactManifest));
+    Logger.info(`✅ Manifesto gerado: ${manifest.files.length} arquivos protegidos`);
+    Logger.info(`📝 Assinatura: ${manifest.signature?.substring(0, 20)}...`);
+}
+/**
+ * Valida integridade de arquivo específico
+ */
+export function validateFileIntegrity(filePath, expectedHash, expectedWatermark) {
+    try {
+        const content = readFileSync(filePath, 'utf8');
+        // Verificar watermark se fornecido
+        if (expectedWatermark && !content.includes(expectedWatermark)) {
+            return false;
+        }
+        // Verificar hash
+        const actualHash = calculateFileHash(filePath);
+        return actualHash === expectedHash;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Script de build - chama esta função após tsc
+ */
+if (import.meta.url.endsWith(process.argv[1])) {
+    const distPath = process.argv[2] || './dist';
+    buildSecurityManifest(distPath);
+}

package/dist/src/security/EulaProtection.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 🔒 Sistema de Proteção EULA - AutoCore Framework
+ *
+ * ⚠️ CRÍTICO: Sistema de proteção de licença e termos de uso
+ * Este módulo implementa verificações de conformidade com EULA
+ */
+/**
+ * Estado do sistema de proteção EULA
+ */
+interface EulaState {
+    accepted: boolean;
+    version: string;
+    acceptedAt?: Date;
+    userAgent?: string;
+    fingerprint?: string;
+}
+/**
+ * 🔒 Classe principal de proteção EULA
+ */
+export declare class EulaProtection {
+    private static instance;
+    private state;
+    private readonly EULA_VERSION;
+    private constructor();
+    /**
+     * Singleton instance
+     */
+    static getInstance(): EulaProtection;
+    /**
+     * 🔍 Verificar se EULA foi aceito
+     */
+    isEulaAccepted(): boolean;
+    /**
+     * ✅ Aceitar EULA
+     */
+    acceptEula(userAgent?: string): void;
+    /**
+     * 🔍 Carregar estado do EULA
+     */
+    private loadEulaState;
+    /**
+     * 💾 Salvar estado do EULA
+     */
+    private saveEulaState;
+    /**
+     * 🔑 Gerar fingerprint único
+     */
+    private generateFingerprint;
+    /**
+     * 📋 Obter termos do EULA
+     */
+    getEulaTerms(): string;
+    /**
+     * 🛡️ Verificar proteção antes de executar
+     */
+    static enforceEula(): void;
+    /**
+     * 📊 Estatísticas do EULA
+     */
+    getStats(): EulaState;
+}
+/**
+ * 🚀 Função de conveniência para aceitar EULA
+ */
+export declare function acceptEula(): void;
+/**
+ * 🔍 Função de conveniência para verificar EULA
+ */
+export declare function isEulaAccepted(): boolean;
+export {};

package/dist/src/security/EulaProtection.js

@@ -0,0 +1,155 @@
+/**
+ * 🔒 Sistema de Proteção EULA - AutoCore Framework
+ *
+ * ⚠️ CRÍTICO: Sistema de proteção de licença e termos de uso
+ * Este módulo implementa verificações de conformidade com EULA
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Logger } from '../utils/Logger.js';
+/**
+ * 🔒 Classe principal de proteção EULA
+ */
+export class EulaProtection {
+    static instance;
+    state;
+    EULA_VERSION = '1.0.0';
+    constructor() {
+        this.state = {
+            accepted: false,
+            version: this.EULA_VERSION,
+        };
+        this.loadEulaState();
+    }
+    /**
+     * Singleton instance
+     */
+    static getInstance() {
+        if (!EulaProtection.instance) {
+            EulaProtection.instance = new EulaProtection();
+        }
+        return EulaProtection.instance;
+    }
+    /**
+     * 🔍 Verificar se EULA foi aceito
+     */
+    isEulaAccepted() {
+        return this.state.accepted && this.state.version === this.EULA_VERSION;
+    }
+    /**
+     * ✅ Aceitar EULA
+     */
+    acceptEula(userAgent) {
+        this.state = {
+            accepted: true,
+            version: this.EULA_VERSION,
+            acceptedAt: new Date(),
+            userAgent,
+            fingerprint: this.generateFingerprint(),
+        };
+        this.saveEulaState();
+    }
+    /**
+     * 🔍 Carregar estado do EULA
+     */
+    loadEulaState() {
+        try {
+            const eulaPath = join(process.cwd(), '.eula-state');
+            if (existsSync(eulaPath)) {
+                const data = readFileSync(eulaPath, 'utf-8');
+                const parsed = JSON.parse(data);
+                // Verificar se é a versão atual
+                if (parsed.version === this.EULA_VERSION) {
+                    this.state = parsed;
+                }
+            }
+        }
+        catch (error) {
+            // Estado padrão em caso de erro
+            this.state.accepted = false;
+        }
+    }
+    /**
+     * 💾 Salvar estado do EULA
+     */
+    saveEulaState() {
+        try {
+            const { writeFileSync } = require('node:fs');
+            const eulaPath = join(process.cwd(), '.eula-state');
+            writeFileSync(eulaPath, JSON.stringify(this.state, null, 2));
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Não foi possível salvar estado do EULA: ${error}`);
+        }
+    }
+    /**
+     * 🔑 Gerar fingerprint único
+     */
+    generateFingerprint() {
+        const { randomBytes } = require('node:crypto');
+        const data = [
+            process.version,
+            process.platform,
+            process.arch,
+            randomBytes(8).toString('hex'),
+        ].join('-');
+        const { createHash } = require('node:crypto');
+        return createHash('sha256').update(data).digest('hex').substring(0, 16);
+    }
+    /**
+     * 📋 Obter termos do EULA
+     */
+    getEulaTerms() {
+        return `
+# 📋 EULA - End User License Agreement
+## AutoCore Framework v${this.EULA_VERSION}
+
+### 🎯 Termos de Uso
+
+1. **Licença**: Este software é licenciado para uso em projetos de automação de testes
+2. **Restrições**: Não é permitida redistribuição sem autorização
+3. **Garantias**: O software é fornecido "como está" sem garantias
+4. **Responsabilidade**: O usuário é responsável pelo uso adequado
+
+### ✅ Aceitação
+
+Ao usar este framework, você concorda com os termos acima.
+    `.trim();
+    }
+    /**
+     * 🛡️ Verificar proteção antes de executar
+     */
+    static enforceEula() {
+        const protection = EulaProtection.getInstance();
+        if (!protection.isEulaAccepted()) {
+            Logger.info('\n' + '='.repeat(60));
+            Logger.info('🔒 PROTEÇÃO EULA ATIVADA');
+            Logger.info('='.repeat(60));
+            Logger.info(protection.getEulaTerms());
+            Logger.info('\n' + '='.repeat(60));
+            Logger.warning('⚠️  Para continuar, aceite os termos do EULA');
+            Logger.info('💡 Execute: EulaProtection.getInstance().acceptEula()');
+            Logger.info('='.repeat(60) + '\n');
+            throw new Error('EULA não aceito. Execute acceptEula() para continuar.');
+        }
+    }
+    /**
+     * 📊 Estatísticas do EULA
+     */
+    getStats() {
+        return { ...this.state };
+    }
+}
+/**
+ * 🚀 Função de conveniência para aceitar EULA
+ */
+export function acceptEula() {
+    EulaProtection.getInstance().acceptEula(process.env.USER_AGENT);
+    Logger.success('✅ EULA aceito com sucesso!');
+}
+/**
+ * 🔍 Função de conveniência para verificar EULA
+ */
+export function isEulaAccepted() {
+    return EulaProtection.getInstance().isEulaAccepted();
+}

package/dist/src/security/HoneypotManager.d.ts

@@ -0,0 +1,46 @@
+/**
+ * HoneypotManager: Sistema de honeypots dinâmicos para detecção de automação
+ * Cria armadilhas invisíveis em tempo de execução que detectam uso por IA
+ */
+export declare class HoneypotManager {
+    private static tripped;
+    private static readonly zeroWidthChars;
+    /**
+     * Verifica se algum honeypot foi ativado
+     */
+    static isTripped(): boolean;
+    /**
+     * Marca um honeypot como ativado
+     */
+    static tripHoneypot(source: string): void;
+    /**
+     * Injeta caracteres invisíveis em strings/comentários TypeScript
+     * Marcam arquivos sem afetar funcionalidade
+     */
+    static injectInvisibleMarkers(content: string, marker?: string): string;
+    /**
+     * Cria source maps com metadados de proteção
+     */
+    static injectSourceMapProtection(sourceMapContent: string): string;
+    /**
+     * Cria arquivos honeypot dinâmicos em diretórios temporários
+     */
+    static createDynamicHoneypots(baseDir: string): void;
+    /**
+     * Gera honeypot TypeScript com aparência legítima
+     */
+    private static generateTsHoneypot;
+    /**
+     * Gera honeypot JSON com configurações falsas mas realistas
+     */
+    private static generateJsonHoneypot;
+    /**
+     * Verifica integridade de arquivos protegidos
+     */
+    static verifyFileIntegrity(filePath: string): boolean;
+    /**
+     * Cria método isento que força degradação quando chamado
+     */
+    static createPoisonMethod(methodName: string): Function;
+}
+export default HoneypotManager;