@silasfmartins/testhub 1.0.0

package/dist/src/global-setup.js

@@ -0,0 +1,1037 @@
+import * as dotenv from 'dotenv';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { loadEnv } from './config/envLoader.js';
+import { resolveJestVitestConflict } from './config/jest-safe-setup.js';
+import { AutoDocs } from './hubdocs/HubDocs.js';
+import { CoverageManager } from './testContext/CoverageManager.js';
+import { UnifiedReportManager } from './testContext/UnifiedReportManager.js';
+import { ConfigLogger } from './utils/ConfigLogger.js';
+import { DataStore } from './utils/DataStore.js';
+import { TerminalLogCapture } from './utils/TerminalLogCapture.js';
+import SystemsManager from './testhub/SystemsManager.js';
+import { ExecutionTracker } from './hubdocs/ExecutionTracker.js';
+import { MobileActions } from './appium/MobileActions.js';
+// Compatibilidade com ES Modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Regex patterns definidos no top level para performance
+const CN_SPEC_PATTERN = /^CN\d+.*\.spec\.ts$/;
+const SPEC_PATTERN = /\.spec\.ts$/;
+export default async function globalSetup() {
+    // 🔧 SOLUÇÃO DEFINITIVA: Resolver conflito Jest/Vitest ANTES de qualquer import
+    resolveJestVitestConflict();
+    // 📋 CRÍTICO: Iniciar captura de logs do terminal ANTES DE TUDO
+    TerminalLogCapture.start();
+    // 🆕 Limpar logs compartilhados do início da execução (cross-worker)
+    TerminalLogCapture.clearSharedLogs();
+    globalThis.TerminalLogCapture = TerminalLogCapture;
+    // ✅ PRIORIDADE MÁXIMA: Limpar arquivos temporários ANTES de qualquer coisa
+    await cleanupTempFiles();
+    dotenv.config();
+    const currentEnv = process.env.ENV || 'development';
+    dotenv.config({ path: `.env.${currentEnv}` });
+    console.log('🏗️  Iniciando setup global...');
+    try {
+        // Determinar o tipo de projeto baseado no environment
+        const projectType = await determineProjectType();
+        console.log(`ℹ️  Tipo de projeto detectado: ${projectType}`);
+        // Configurar PROJECT_TYPE no environment se não estiver definido
+        if (!process.env.PROJECT_TYPE) {
+            process.env.PROJECT_TYPE = projectType;
+        }
+        // ✅ NOVO: Inicializar DataStore para compartilhamento entre projetos
+        DataStore.set('PROJECT_TYPE', projectType);
+        DataStore.set('START_TIME', new Date().toISOString());
+        DataStore.set('NODE_ENV', currentEnv);
+        // 📚 NOVO: Inicializar sistema de documentação automática
+        try {
+            const projectName = process.env.npm_package_name || `AutoCore ${projectType} Tests`;
+            await AutoDocs.initialize({
+                projectName,
+                outputDir: './docs',
+                config: {
+                    enabled: process.env.AUTODOCS_ENABLED !== 'false',
+                    generateSwagger: true,
+                    includeScreenshots: process.env.NODE_ENV !== 'ci',
+                },
+            });
+            // ✅ CRÍTICO: Inicializar ExecutionTracker com detecção automática
+            ExecutionTracker.initialize(projectName, projectType);
+            globalThis.AutoDocs = AutoDocs;
+            globalThis.ExecutionTracker = ExecutionTracker;
+        }
+        catch (error) {
+            console.warn('⚠️ Falha ao inicializar AutoDocs, continuando sem documentação:', error);
+        }
+        // 🌐 NOVO: Inicializar TestHub Systems Manager
+        try {
+            const systemsManager = SystemsManager.getInstance();
+            // Inicializar (carrega sistemas do backend e gera enum)
+            await systemsManager.initialize();
+            globalThis.SystemsManager = systemsManager;
+            console.log('✅ TestHub Systems carregados e disponíveis');
+        }
+        catch (error) {
+            console.warn('⚠️ Falha ao inicializar TestHub Systems, continuando sem integração:', error);
+            console.warn('   Os testes continuarão normalmente usando configuração manual (.env)');
+        }
+        // Configurar logs específicos por tipo de projeto
+        ConfigLogger.init({
+            projectName: `AutoCore ${projectType} Tests`,
+            logToFile: process.env.LOG_TO_FILE === 'true',
+        });
+        // Carregar variáveis de ambiente
+        loadEnv({
+            logConfig: true,
+            silent: false,
+            loadModeSpecificFiles: true,
+        });
+        // Mostrar informações do sistema
+        displaySystemInfo();
+        // ✅ NOVO: Verificar e configurar estruturas obrigatórias (gated)
+        // Só cria estrutura quando explicitamente solicitado
+        if (process.env.AUTOCORE_CREATE_STRUCTURE === 'true') {
+            await ensureRequiredStructure(projectType);
+        }
+        else {
+            console.log('📁 Criação de estrutura pulada (AUTOCORE_CREATE_STRUCTURE != true)');
+        }
+        // Verificar configuração do Playwright
+        checkPlaywrightConfig();
+        // Inicializar contextos específicos
+        await initializeContexts(projectType);
+        // Verificar recursos necessários
+        await checkProjectResources(projectType);
+        // ✅ MELHORADO: Verificação mais detalhada de ambiente
+        checkEnvironmentVariables(projectType);
+        // ✅ NOVO: Configurar métricas de sistema
+        setupSystemMetrics();
+        // Inicializar sistema de relatórios unificado
+        UnifiedReportManager.registrarInicioExecucao();
+        // 🤖 NOVO: Inicializar sistema de coverage automático
+        await CoverageManager.autoInitialize();
+        // ✅ NOVO: Registrar informações iniciais do setup
+        await recordSetupMetrics(projectType, currentEnv);
+        console.log('✅ Setup global concluído com sucesso!');
+        // ✅ NOVO: Log de resumo do setup
+        logSetupSummary(projectType, currentEnv);
+    }
+    catch (error) {
+        console.error('❌ Erro durante setup global');
+        console.error(error);
+        // ✅ NOVO: Registrar erro no sistema de relatórios
+        try {
+            console.error(`❌ Erro durante setup: ${String(error)}`);
+        }
+        catch {
+            // Ignorar se não conseguir registrar
+        }
+        throw error;
+    }
+}
+/**
+ * ✅ FUNÇÃO MELHORADA: Limpeza robusta de arquivos temporários
+ * Executa ANTES de qualquer configuração para evitar falhas
+ */
+async function cleanupTempFiles() {
+    const cwd = process.cwd();
+    // ✅ EXPANDIDO: Lista mais completa de arquivos temporários
+    const tempFiles = [
+        '.env.lock',
+        '.configlogger.lock',
+        '.test-data-store.json',
+        '.autocore.lock',
+        '.setup.lock',
+    ];
+    const tempDirs = [
+        'playwright/.auth',
+        'test-results/.tmp',
+        '.rbqa', // ✅ AUTODOCS: Limpar dados antigos do ExecutionTracker
+    ];
+    await cleanupFiles(tempFiles, cwd);
+    await cleanupDirectories(tempDirs, cwd);
+    // Pequena pausa para garantir que o sistema de arquivos processou as remoções
+    await new Promise((resolve) => setTimeout(resolve, 100));
+}
+/**
+ * Limpeza de arquivos individuais
+ */
+async function cleanupFiles(files, basePath) {
+    let filesRemoved = 0;
+    let errors = 0;
+    for (const fileName of files) {
+        const filePath = path.join(basePath, fileName);
+        try {
+            if (fs.existsSync(filePath)) {
+                await removeFileWithFallback(filePath);
+                filesRemoved++;
+            }
+        }
+        catch (error) {
+            console.error(`❌ Erro ao remover ${fileName}: ${String(error)}`);
+            errors++;
+        }
+    }
+    if (errors > 0) {
+        console.warn(`⚠️ ${errors} erro(s) durante limpeza de arquivos - os testes continuarão`);
+    }
+}
+/**
+ * Limpeza de diretórios
+ */
+async function cleanupDirectories(dirs, basePath) {
+    let dirsRemoved = 0;
+    let errors = 0;
+    for (const dirName of dirs) {
+        const dirPath = path.join(basePath, dirName);
+        try {
+            if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+                fs.rmSync(dirPath, { recursive: true, force: true });
+                dirsRemoved++;
+            }
+        }
+        catch (error) {
+            console.error(`❌ Erro ao remover diretório ${dirName}: ${String(error)}`);
+            errors++;
+        }
+    }
+    if (errors > 0) {
+        console.warn(`⚠️ ${errors} erro(s) durante limpeza de diretórios - os testes continuarão`);
+    }
+}
+/**
+ * Remove arquivo com fallback para Windows
+ */
+async function removeFileWithFallback(filePath) {
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch (unlinkError) {
+        // Fallback para Windows com alteração de permissões
+        if (process.platform === 'win32') {
+            try {
+                fs.chmodSync(filePath, 0o666);
+                fs.unlinkSync(filePath);
+            }
+            catch (forceError) {
+                throw forceError;
+            }
+        }
+        else {
+            throw unlinkError;
+        }
+    }
+}
+/**
+ * ✅ NOVA FUNÇÃO: Garantir estruturas obrigatórias
+ */
+async function ensureRequiredStructure(projectType) {
+    console.log('📁 Verificando estruturas obrigatórias...');
+    const cwd = process.cwd();
+    const requiredDirs = [
+        'tests',
+        'screenshots',
+        'test-results',
+        'playwright-report',
+    ];
+    // Diretórios específicos por tipo de projeto
+    const typeSpecificDirs = {
+        API: ['src/statements', 'src/request'],
+        Frontend: ['src/pages', 'src/attributes'],
+        Mobile: ['src/pages'],
+        SSH: ['src/statements'],
+        Banco: ['src/models', 'src/services'],
+        Scenarios: ['tests'],
+    };
+    const allRequiredDirs = [
+        ...requiredDirs,
+        ...(typeSpecificDirs[projectType] || []),
+    ];
+    await createDirectories(allRequiredDirs, cwd);
+    await createEssentialFiles(projectType, cwd);
+}
+/**
+ * Criar diretórios necessários
+ */
+async function createDirectories(dirs, basePath) {
+    for (const dir of dirs) {
+        const dirPath = path.join(basePath, dir);
+        if (!fs.existsSync(dirPath)) {
+            try {
+                fs.mkdirSync(dirPath, { recursive: true });
+                console.log(`📁 Criado diretório: ${dir}`);
+            }
+            catch (error) {
+                console.warn(`⚠️ Erro ao criar diretório ${dir}: ${String(error)}`);
+            }
+        }
+    }
+}
+/**
+ * ✅ NOVA FUNÇÃO: Criar arquivos essenciais
+ */
+async function createEssentialFiles(projectType, cwd) {
+    await createDefaultEnvFile(cwd);
+    await updateGitignoreFile(cwd);
+}
+/**
+ * Criar arquivo .env padrão se não existir
+ */
+async function createDefaultEnvFile(cwd) {
+    const envPath = path.join(cwd, '.env');
+    if (!fs.existsSync(envPath)) {
+        const defaultEnv = `# Arquivo que seleciona o ambiente a ser utilizado
+ENV=preprod
+
+# Configurações básicas
+SCREENSHOTS_ENABLED=false
+LOG_LEVEL=info
+LOG_TO_FILE=false
+`;
+        fs.writeFileSync(envPath, defaultEnv);
+        console.log('📄 Criado arquivo .env padrão');
+    }
+}
+/**
+ * Atualizar .gitignore com entradas do AutoCore
+ */
+async function updateGitignoreFile(cwd) {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    const tempIgnoreEntries = [
+        '# Arquivos temporários do AutoCore',
+        '.env.lock',
+        '.configlogger.lock',
+        '.test-data-store.json',
+        '.autocore.lock',
+        '.setup.lock',
+        'test-results/',
+        'playwright-report/',
+        'screenshots/',
+        'evidencias/',
+        'downloads/',
+    ];
+    if (fs.existsSync(gitignorePath)) {
+        const gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8');
+        const missingEntries = tempIgnoreEntries.filter((entry) => !gitignoreContent.includes(entry));
+        if (missingEntries.length > 0) {
+            const newContent = `\n\n${missingEntries.join('\n')}\n`;
+            fs.appendFileSync(gitignorePath, newContent);
+            console.log(`📄 Adicionadas ${missingEntries.length} entradas ao .gitignore`);
+        }
+    }
+}
+/**
+ * ✅ NOVA FUNÇÃO: Configurar métricas de sistema
+ */
+function setupSystemMetrics() {
+    console.log('📊 Configurando métricas de sistema...');
+    try {
+        // Registrar informações iniciais no DataStore
+        const memInfo = process.memoryUsage();
+        const systemInfo = {
+            startTime: Date.now(),
+            initialMemory: {
+                heapUsed: Math.round(memInfo.heapUsed / 1024 / 1024), // MB
+                heapTotal: Math.round(memInfo.heapTotal / 1024 / 1024), // MB
+                external: Math.round(memInfo.external / 1024 / 1024), // MB
+            },
+            cpuInfo: {
+                count: os.cpus().length,
+                architecture: process.arch,
+                platform: process.platform,
+            },
+            nodeVersion: process.version,
+            environment: process.env.ENV || 'development',
+        };
+        DataStore.set('SYSTEM_METRICS', systemInfo);
+        console.log('📊 Métricas de sistema registradas');
+    }
+    catch (error) {
+        console.warn('⚠️ Erro ao configurar métricas:', error);
+    }
+}
+/**
+ * ✅ NOVA FUNÇÃO: Registrar métricas do setup
+ */
+async function recordSetupMetrics(projectType, environment) {
+    try {
+        const setupInfo = {
+            projectType,
+            environment,
+            nodeVersion: process.version,
+            platform: process.platform,
+            setupCompletedAt: new Date().toISOString(),
+            totalMemoryGB: Math.round(os.totalmem() / 1024 / 1024 / 1024),
+            cpuCount: os.cpus().length,
+        };
+        DataStore.set('SETUP_INFO', setupInfo);
+        console.log('📋 Informações do setup registradas');
+    }
+    catch (error) {
+        console.warn('⚠️ Erro ao registrar métricas do setup:', error);
+    }
+}
+/**
+ * ✅ NOVA FUNÇÃO: Log de resumo do setup
+ */
+function logSetupSummary(projectType, environment) {
+    console.log('\n📋 === Resumo do Setup ===');
+    console.log(`🎯 Tipo de projeto: ${projectType}`);
+    console.log(`🌍 Ambiente: ${environment}`);
+    console.log(`⚡ Node.js: ${process.version}`);
+    console.log(`💻 Plataforma: ${process.platform} (${process.arch})`);
+    console.log(`🧠 CPUs disponíveis: ${os.cpus().length}`);
+    console.log(`💾 Memória total: ${Math.round(os.totalmem() / 1024 / 1024 / 1024)}GB`);
+    // ✅ NOVO: Mostrar variáveis críticas configuradas
+    const criticalVars = ['BASE_URL', 'BASE_URL_API', 'DB_HOST', 'SSH_HOST'];
+    const configuredVars = criticalVars.filter((varName) => process.env[varName]);
+    if (configuredVars.length > 0) {
+        console.log(`⚙️  Variáveis críticas: ${configuredVars.join(', ')}`);
+    }
+    console.log(`📁 Diretório: ${process.cwd()}`);
+    console.log('✨ Setup concluído com sucesso!\n');
+}
+/**
+ * ✅ MELHORADA: Verificação genérica de variáveis de ambiente com detalhes por tipo
+ * Não para os testes, apenas informa sobre configuração
+ */
+function checkEnvironmentVariables(projectType) {
+    console.log('ℹ️  === Verificação de Configuração ===');
+    // Contar variáveis não vazias (excluindo ENV)
+    const allEnvVars = Object.keys(process.env).filter((key) => key !== 'ENV' &&
+        process.env[key] &&
+        (process.env[key] ?? '').trim() !== '');
+    // ✅ NOVO: Verificações específicas por tipo (apenas informativas)
+    const typeSpecificVars = {
+        API: ['BASE_URL', 'BASE_URL_API', 'BASE_URL_TOKEN'],
+        Frontend: ['BASE_URL'],
+        Mobile: ['APPIUM_SERVER_URL', 'DEVICE_NAME'],
+        SSH: ['SSH_HOST', 'SSH_USER'],
+        Banco: ['DB_HOST', 'DB_USER', 'DB_SERVICE_NAME'],
+        Scenarios: ['BASE_URL', 'OCTANE_URL'],
+    };
+    const suggestedVars = typeSpecificVars[projectType] || [];
+    const configuredSuggested = suggestedVars.filter((varName) => process.env[varName]);
+    console.log(`ℹ️  Total de variáveis configuradas: ${allEnvVars.length}`);
+    if (configuredSuggested.length > 0) {
+        console.log(`✅ Variáveis específicas para ${projectType}: ${configuredSuggested.join(', ')}`);
+    }
+    if (allEnvVars.length <= 3) {
+        console.warn('⚠️ Poucas variáveis de ambiente configuradas.');
+        console.warn(`💡 Recomendação para ${projectType}: Configure variáveis como ${suggestedVars.join(', ')}`);
+        console.warn('📁 Use os arquivos .env.* para diferentes ambientes');
+        console.warn('ℹ️  Os testes continuarão normalmente.');
+    }
+    else {
+        console.log('✅ Configuração de ambiente adequada');
+    }
+    // ✅ NOVO: Mostrar arquivos .env encontrados
+    const envFiles = [
+        '.env',
+        '.env.preprod',
+        '.env.esteira1',
+        '.env.esteira2',
+        '.env.prodlike',
+    ];
+    const existingEnvFiles = envFiles.filter((file) => fs.existsSync(path.join(process.cwd(), file)));
+    if (existingEnvFiles.length > 0) {
+        console.log(`📋 Arquivos de ambiente: ${existingEnvFiles.join(', ')}`);
+    }
+}
+/**
+ * Determinar tipo de projeto (otimizada para complexidade)
+ */
+async function determineProjectType() {
+    const cwd = process.cwd();
+    try {
+        // ✅ PRIORIDADE: Honor CI / pipeline overrides (force test type)
+        const overrideType = (process.env.FORCE_TEST_TYPE ||
+            process.env.TEST_TYPE ||
+            process.env.RUN_TEST_TYPE ||
+            '').toLowerCase();
+        if (overrideType) {
+            if (overrideType.includes('ssh'))
+                return 'SSH';
+            if (overrideType.includes('scenario') || overrideType.includes('scenarios'))
+                return 'Scenarios';
+            if (overrideType.includes('frontend') || overrideType.includes('playwright') || overrideType.includes('web'))
+                return 'Frontend';
+            if (overrideType.includes('api'))
+                return 'API';
+            if (overrideType.includes('mobile'))
+                return 'Mobile';
+            if (overrideType.includes('banco') || overrideType.includes('db'))
+                return 'Banco';
+        }
+        // 1. Detectar por nome do projeto no package.json
+        const projectNameType = await detectByProjectName(cwd);
+        if (projectNameType) {
+            return projectNameType;
+        }
+        // 2. Detectar por estrutura de arquivos
+        const structureType = await detectByFileStructure(cwd);
+        if (structureType) {
+            return structureType;
+        }
+        // 3. Detectar por variáveis de ambiente
+        const envType = detectByEnvironmentVars();
+        if (envType) {
+            return envType;
+        }
+        // 4. Detectar por arquivos de teste
+        const testType = await detectByTestFiles(cwd);
+        if (testType) {
+            return testType;
+        }
+        return 'Frontend'; // fallback
+    }
+    catch (error) {
+        console.warn('⚠️ Erro ao detectar tipo de projeto:', error);
+        return 'API';
+    }
+}
+/**
+ * Detectar tipo por nome do projeto
+ */
+async function detectByProjectName(cwd) {
+    const packageJsonPath = path.join(cwd, 'package.json');
+    const folderName = path.basename(cwd).toLowerCase();
+    // Treat projects with `-pw` suffix as Scenarios by default (CI convention)
+    if (folderName.endsWith('-pw')) {
+        console.log(`📁 Nome da pasta termina com -pw: ${folderName} → tratando como Scenarios por padrão`);
+        // If folder name explicitly contains 'playwright' prefer Frontend
+        if (folderName.includes('playwright')) {
+            console.log('   (contém "playwright" no nome, tratando como Frontend)');
+            return 'Frontend';
+        }
+        return 'Scenarios';
+    }
+    // ✅ NOVA: Verificar nome da pasta antes do package.json
+    const folderPatterns = [
+        // ✅ PRIORIDADE MÁXIMA: Detectar cenários/scenarios primeiro (mais específico)
+        { pattern: /cenario|scenario/i, type: 'Scenarios' }, // Case insensitive, pega qualquer variação
+        { pattern: /mobile|appium|android|ios/, type: 'Mobile' },
+        { pattern: /oss-api|test-oss-api|service|rest/, type: 'API' }, // Mais específico para API
+        { pattern: /\bapi\b/, type: 'API' }, // API como palavra completa
+        { pattern: /frontend|web|ui|playwright/, type: 'Frontend' },
+        { pattern: /ssh|terminal|shell/, type: 'SSH' },
+        { pattern: /banco|database|db|sql/, type: 'Banco' },
+    ];
+    for (const { pattern, type } of folderPatterns) {
+        if (pattern.test(folderName)) {
+            console.log(`📁 Tipo detectado por nome da pasta: ${folderName} → ${type}`);
+            return type;
+        }
+    }
+    if (!fs.existsSync(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const packageContent = fs.readFileSync(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(packageContent);
+        const projectName = (packageJson.name || '').toLowerCase();
+        // If package name ends with -pw treat as Scenarios unless it explicitly references playwright
+        if (projectName.endsWith('-pw')) {
+            console.log(`📦 package.json name ends with -pw: ${projectName} → treating as Scenarios by default`);
+            if (projectName.includes('playwright')) {
+                console.log('   (package name contains "playwright", treating as Frontend)');
+                return 'Frontend';
+            }
+            return 'Scenarios';
+        }
+        const namePatterns = [
+            // ✅ PRIORIDADE MÁXIMA: Detectar cenários/scenarios primeiro (mais específico)
+            { pattern: /cenario|scenario/i, type: 'Scenarios' }, // Case insensitive
+            { pattern: /mobile|appium|android|ios/, type: 'Mobile' },
+            { pattern: /oss-api|test-oss-api|service|rest/, type: 'API' }, // Mais específico para API
+            { pattern: /\bapi\b/, type: 'API' }, // API como palavra completa
+            { pattern: /frontend|web|ui|playwright/, type: 'Frontend' },
+            { pattern: /ssh|terminal|shell/, type: 'SSH' },
+            { pattern: /banco|database|db|sql/, type: 'Banco' },
+        ];
+        for (const { pattern, type } of namePatterns) {
+            if (pattern.test(projectName)) {
+                console.log(`📦 Tipo detectado por package.json: ${projectName} → ${type}`);
+                return type;
+            }
+        }
+    }
+    catch {
+        // Ignorar erro de parse
+    }
+    return null;
+}
+/**
+ * Detectar tipo por estrutura de arquivos
+ */
+async function detectByFileStructure(cwd) {
+    const srcDir = path.join(cwd, 'src');
+    const testsDir = path.join(cwd, 'tests');
+    // Scenarios: ausência da pasta src + presença de CN*.spec.ts
+    if (!fs.existsSync(srcDir) && fs.existsSync(testsDir)) {
+        try {
+            const hasScenarios = fs
+                .readdirSync(testsDir)
+                .some((f) => CN_SPEC_PATTERN.test(f));
+            if (hasScenarios) {
+                return 'Scenarios';
+            }
+        }
+        catch {
+            // Ignorar erro de leitura
+        }
+    }
+    // Banco: arquivos específicos
+    const bancoFiles = [
+        'src/models/ModelDBA.ts',
+        'src/models/ModelDBA.js',
+        'src/services/ServiceSiebel.ts',
+        'src/services/ServiceSiebel.js',
+    ];
+    for (const file of bancoFiles) {
+        if (fs.existsSync(path.join(cwd, file))) {
+            return 'Banco';
+        }
+    }
+    // Banco: pastas típicas
+    if (fs.existsSync(path.join(cwd, 'src', 'models')) ||
+        fs.existsSync(path.join(cwd, 'src', 'services'))) {
+        return 'Banco';
+    }
+    // Mobile: wdio.conf
+    if (fs.existsSync(path.join(cwd, 'wdio.conf.ts')) ||
+        fs.existsSync(path.join(cwd, 'wdio.conf.js'))) {
+        return 'Mobile';
+    }
+    return null;
+}
+/**
+ * Detectar tipo por variáveis de ambiente
+ */
+function detectByEnvironmentVars() {
+    if (process.env.USE_MOBILE === 'true') {
+        return 'Mobile';
+    }
+    if (process.env.USE_SSH === 'true') {
+        return 'SSH';
+    }
+    if (process.env.USE_BANCO === 'true') {
+        return 'Banco';
+    }
+    return null;
+}
+/**
+ * Detectar tipo por arquivos de teste
+ */
+async function detectByTestFiles(cwd) {
+    const testsDir = path.join(cwd, 'tests');
+    if (!fs.existsSync(testsDir)) {
+        return null;
+    }
+    try {
+        const hasSpecFiles = fs
+            .readdirSync(testsDir)
+            .some((f) => SPEC_PATTERN.test(f));
+        return hasSpecFiles ? 'API' : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Verificar recursos sem require()
+ */
+async function checkProjectResources(projectType) {
+    console.log('ℹ️  === Verificação de Recursos ===');
+    const cwd = process.cwd();
+    try {
+        // Verificar estrutura de pastas
+        const testDir = path.join(cwd, 'tests');
+        if (!fs.existsSync(testDir)) {
+            console.warn('⚠️ Pasta "tests" não encontrada, criando...');
+            fs.mkdirSync(testDir, { recursive: true });
+        }
+        // Verificar configurações específicas por tipo
+        const resourceCheckers = {
+            Mobile: checkMobileResources,
+            API: checkApiResources,
+            Frontend: checkFrontendResources,
+            SSH: checkSSHResources,
+            Banco: checkBancoResources,
+            Scenarios: checkScenariosResources,
+        };
+        const checker = resourceCheckers[projectType];
+        if (checker) {
+            await checker(cwd);
+        }
+        console.log('✅ Verificação de recursos concluída');
+    }
+    catch (error) {
+        console.warn('⚠️ Erro na verificação de recursos:', error);
+        // Não falhar o setup por problemas de verificação
+    }
+}
+/**
+ * Verificações específicas para projetos API
+ */
+function checkApiResources(cwd) {
+    return new Promise((resolve) => {
+        console.log('ℹ️  Verificando recursos para projeto API...');
+        // Verificar se há arquivos .env
+        const envFiles = ['.env', '.env.preprod', '.env.esteira1'];
+        const existingEnvFiles = envFiles.filter((file) => fs.existsSync(path.join(cwd, file)));
+        if (existingEnvFiles.length > 0) {
+            console.log(`✅ Arquivos .env encontrados: ${existingEnvFiles.join(', ')}`);
+        }
+        else {
+            console.warn('⚠️ Nenhum arquivo .env encontrado - Configure conforme necessário');
+        }
+        // Verificar estrutura de pastas típica de API
+        const apiDirs = ['src/statements', 'src/request', 'src/services'];
+        const existingDirs = apiDirs.filter((dir) => fs.existsSync(path.join(cwd, dir)));
+        if (existingDirs.length > 0) {
+            console.log(`✅ Estrutura API encontrada: ${existingDirs.join(', ')}`);
+        }
+        else {
+            console.log('ℹ️  Estrutura será criada conforme necessário');
+        }
+        resolve();
+    });
+}
+/**
+ * Verificações para outros tipos de projeto
+ */
+function checkMobileResources(cwd) {
+    return new Promise((resolve) => {
+        console.log('ℹ️  Verificando recursos para projeto Mobile...');
+        const isMobileProject = detectMobileProject(cwd);
+        if (isMobileProject) {
+            checkDedicatedMobileProject(cwd);
+        }
+        else {
+            console.log('✅ Capacidades Mobile disponíveis via AutoCore');
+        }
+        checkMobileEnvironmentFiles(cwd);
+        resolve();
+    });
+}
+/**
+ * Detectar se é projeto mobile dedicado
+ */
+function detectMobileProject(cwd) {
+    const packageJsonPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        return false;
+    }
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const mobileDeps = ['webdriverio', '@wdio/cli'];
+        const mobileScripts = ['appium:start', 'test:android', 'test:ios'];
+        const hasMobileDeps = mobileDeps.some((dep) => packageJson.dependencies?.[dep] || packageJson.devDependencies?.[dep]);
+        const hasMobileScripts = mobileScripts.some((script) => packageJson.scripts?.[script]);
+        return hasMobileDeps || hasMobileScripts;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Verificar projeto mobile dedicado
+ */
+function checkDedicatedMobileProject(cwd) {
+    const wdioConfig = fs.existsSync(path.join(cwd, 'wdio.conf.ts')) ||
+        fs.existsSync(path.join(cwd, 'wdio.conf.js'));
+    if (wdioConfig) {
+        console.log('✅ Configuração WebdriverIO encontrada');
+    }
+    else {
+        console.log('ℹ️  Configuração WebdriverIO será criada quando necessário');
+    }
+    const appsDir = fs.existsSync(path.join(cwd, 'apps'));
+    if (appsDir) {
+        console.log('✅ Diretório apps/ encontrado');
+    }
+    else {
+        console.log('ℹ️  Diretório apps/ será criado conforme necessário');
+    }
+}
+/**
+ * Verificar arquivos de ambiente mobile
+ */
+function checkMobileEnvironmentFiles(cwd) {
+    const mobileEnvFiles = [
+        '.env.preprod',
+        '.env.esteira1',
+        '.env.esteira2',
+        '.env.prodlike',
+    ].filter((file) => fs.existsSync(path.join(cwd, file))).length;
+    if (mobileEnvFiles > 0) {
+        console.log(`✅ ${mobileEnvFiles} arquivo(s) de ambiente encontrado(s)`);
+    }
+    else {
+        console.log('ℹ️  Arquivos de ambiente serão criados conforme necessário');
+    }
+}
+function checkFrontendResources(cwd) {
+    return new Promise((resolve) => {
+        console.log('ℹ️  Verificando recursos para projeto Frontend...');
+        const playwrightConfig = fs.existsSync(path.join(cwd, 'playwright.config.ts')) ||
+            fs.existsSync(path.join(cwd, 'playwright.config.js'));
+        if (playwrightConfig) {
+            console.log('✅ Configuração Playwright encontrada');
+        }
+        else {
+            console.warn('⚠️ Configuração Playwright não encontrada');
+        }
+        // Verificar estrutura típica de Frontend
+        const frontendDirs = ['src/pages', 'src/page-objects', 'src/attributes'];
+        const existingDirs = frontendDirs.filter((dir) => fs.existsSync(path.join(cwd, dir)));
+        if (existingDirs.length > 0) {
+            console.log(`✅ Estrutura Frontend encontrada: ${existingDirs.join(', ')}`);
+        }
+        else {
+            console.log('ℹ️  Estrutura será criada conforme necessário');
+        }
+        resolve();
+    });
+}
+function checkSSHResources(cwd) {
+    return new Promise((resolve) => {
+        console.log('ℹ️  Verificando recursos para projeto SSH...');
+        // Verificar estrutura típica de SSH
+        const sshDirs = ['src/statements', 'secrets'];
+        const existingDirs = sshDirs.filter((dir) => fs.existsSync(path.join(cwd, dir)));
+        if (existingDirs.length > 0) {
+            console.log(`✅ Estrutura SSH encontrada: ${existingDirs.join(', ')}`);
+        }
+        else {
+            console.log('ℹ️  Estrutura será criada conforme necessário');
+        }
+        // Verificar arquivos de configuração SSH
+        const envFiles = ['.env.preprod', '.env.esteira1', '.env.esteira2'];
+        const existingEnvFiles = envFiles.filter((file) => fs.existsSync(path.join(cwd, file)));
+        if (existingEnvFiles.length > 0) {
+            console.log(`✅ Configurações de ambiente: ${existingEnvFiles.join(', ')}`);
+        }
+        else {
+            console.log('ℹ️  Configure variáveis SSH nos arquivos .env.*');
+        }
+        resolve();
+    });
+}
+function checkBancoResources(cwd) {
+    return new Promise((resolve) => {
+        console.log('ℹ️  Verificando recursos para projeto Banco...');
+        // Verificar estrutura típica de Banco
+        const bancoDirs = ['src/models', 'src/services'];
+        const existingDirs = bancoDirs.filter((dir) => fs.existsSync(path.join(cwd, dir)));
+        if (existingDirs.length > 0) {
+            console.log(`✅ Estrutura Banco encontrada: ${existingDirs.join(', ')}`);
+        }
+        else {
+            console.log('ℹ️  Estrutura será criada conforme necessário');
+        }
+        // Verificar arquivos específicos de banco
+        const bancoFiles = [
+            'src/models/ModelDBA.ts',
+            'src/services/ServiceSiebel.ts',
+        ];
+        const existingFiles = bancoFiles.filter((file) => fs.existsSync(path.join(cwd, file)));
+        if (existingFiles.length > 0) {
+            console.log(`✅ Arquivos de banco encontrados: ${existingFiles.length}`);
+        }
+        else {
+            console.log('ℹ️  Arquivos de modelo e serviço serão criados conforme necessário');
+        }
+        resolve();
+    });
+}
+function checkScenariosResources(cwd) {
+    return new Promise((resolve) => {
+        console.log('ℹ️  Verificando recursos para projeto Scenarios...');
+        // Verificar se existem arquivos CN*.spec.ts
+        const testsDir = path.join(cwd, 'tests');
+        if (fs.existsSync(testsDir)) {
+            const scenarioFiles = fs
+                .readdirSync(testsDir)
+                .filter((f) => CN_SPEC_PATTERN.test(f));
+            if (scenarioFiles.length > 0) {
+                console.log(`✅ ${scenarioFiles.length} arquivo(s) de cenário encontrado(s)`);
+            }
+            else {
+                console.log('ℹ️  Nenhum arquivo de cenário (CN*.spec.ts) encontrado');
+            }
+        }
+        // Verificar configurações de ambiente
+        const envFiles = [
+            '.env.preprod',
+            '.env.esteira1',
+            '.env.esteira2',
+            '.env.prodlike',
+        ];
+        const existingEnvFiles = envFiles.filter((file) => fs.existsSync(path.join(cwd, file)));
+        if (existingEnvFiles.length > 0) {
+            console.log(`✅ Configurações de ambiente: ${existingEnvFiles.join(', ')}`);
+        }
+        else {
+            console.log('ℹ️  Configure variáveis nos arquivos .env.* conforme necessário');
+        }
+        resolve();
+    });
+}
+/**
+ * 🧹 Limpa screenshots web da execução anterior
+ */
+async function cleanWebScreenshots() {
+    try {
+        const screenshotDir = path.join(process.cwd(), 'test-results', 'web-screenshots');
+        if (fs.existsSync(screenshotDir)) {
+            const files = fs.readdirSync(screenshotDir);
+            const imageFiles = files.filter((file) => file.endsWith('.png') ||
+                file.endsWith('.jpg') ||
+                file.endsWith('.jpeg'));
+            for (const file of imageFiles) {
+                const filePath = path.join(screenshotDir, file);
+                fs.unlinkSync(filePath);
+            }
+            console.log(`🧹 Limpos ${imageFiles.length} screenshot(s) web da execução anterior`);
+        }
+        else {
+            fs.mkdirSync(screenshotDir, { recursive: true });
+            console.log(`📁 Diretório de screenshots web criado: ${screenshotDir}`);
+        }
+    }
+    catch (error) {
+        console.log(`⚠️ Erro ao limpar screenshots web: ${String(error)}`);
+    }
+}
+/**
+ * Inicializar contextos específicos por tipo de projeto
+ */
+async function initializeContexts(projectType) {
+    console.log('ℹ️  === Inicialização de Contextos ===');
+    try {
+        const contextInfo = {
+            API: [
+                '✅ Inicializando contextos para projeto API',
+                'ℹ️  - ApiActions disponível para requisições HTTP',
+                'ℹ️  - Validações de response automáticas',
+                'ℹ️  - Cache de requisições habilitado',
+            ],
+            Frontend: [
+                '✅ Inicializando contextos para projeto Frontend',
+                'ℹ️  - Actions disponível para automação web',
+                'ℹ️  - Screenshots automáticos em falhas',
+                'ℹ️  - Navegação e interação com elementos',
+            ],
+            Mobile: [
+                '✅ Inicializando contextos para projeto Mobile',
+                'ℹ️  - MobileActions disponível para automação mobile',
+                'ℹ️  - WebdriverIO configurado',
+                'ℹ️  - Gestos e interações touch',
+            ],
+            SSH: [
+                '✅ Inicializando contextos para projeto SSH',
+                'ℹ️  - SSHActions disponível para comandos remotos',
+                'ℹ️  - Conexões seguras',
+                'ℹ️  - Execução de scripts remotos',
+            ],
+            Banco: [
+                '✅ Inicializando contextos para projeto Banco',
+                'ℹ️  - BancoHelper disponível para queries',
+                'ℹ️  - Conexões Oracle/SQL',
+                'ℹ️  - Cache de resultados',
+            ],
+            Scenarios: [
+                '✅ Inicializando contextos para projeto Scenarios',
+                'ℹ️  - Statements disponíveis para cenários',
+                'ℹ️  - Relatórios e evidências automáticas',
+                'ℹ️  - Suporte a múltiplos tipos de teste',
+            ],
+        };
+        const messages = contextInfo[projectType] || [];
+        messages.forEach((message) => console.log(message));
+        // 🧹 Limpeza específica por tipo de projeto
+        if (projectType === 'Mobile') {
+            try {
+                await MobileActions.cleanMobileScreenshots();
+            }
+            catch (error) {
+                console.log('⚠️ Erro ao limpar screenshots mobile:', error);
+            }
+        }
+        // 🧹 Limpeza de screenshots Web/Frontend
+        if (projectType === 'Frontend' || projectType === 'Mixed') {
+            try {
+                await cleanWebScreenshots();
+            }
+            catch (error) {
+                console.log('⚠️ Erro ao limpar screenshots web:', error);
+            }
+        }
+        console.log(`📊 Sistema de relatórios unificado ativo para ${projectType}`);
+        console.log('ℹ️  - Logs automáticos em tempo real');
+        console.log('ℹ️  - Relatórios HTML visuais');
+        console.log('ℹ️  - Métricas e analytics integrados');
+    }
+    catch (error) {
+        console.warn('⚠️ Erro ao inicializar contextos:', error);
+    }
+}
+/**
+ * Exibir informações do sistema sem require()
+ */
+function displaySystemInfo() {
+    console.log('ℹ️  === Configuração do Ambiente ===');
+    console.log(`ℹ️  Node.js: ${process.version}`);
+    console.log(`ℹ️  Sistema operacional: ${process.platform} ${process.arch}`);
+    const totalMemGB = Math.round(os.totalmem() / 1024 / 1024 / 1024);
+    const freeMemGB = Math.round(os.freemem() / 1024 / 1024 / 1024);
+    const heapUsed = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
+    const heapTotal = Math.round(process.memoryUsage().heapTotal / 1024 / 1024);
+    console.log(`ℹ️  Memória total: ${totalMemGB}GB`);
+    console.log(`ℹ️  Memória disponível: ${freeMemGB}GB`);
+    console.log(`ℹ️  Heap usado: ${heapUsed}MB / ${heapTotal}MB`);
+    console.log(`ℹ️  CPUs: ${os.cpus().length} núcleos`);
+    console.log(`ℹ️  Usuário: ${process.env.USERNAME || process.env.USER || 'N/A'}`);
+    console.log(`ℹ️  Nome da máquina: ${os.hostname()}`);
+    console.log(`ℹ️  Diretório de trabalho: ${process.cwd()}`);
+    // Mostrar ambiente selecionado
+    const currentEnv = process.env.ENV || process.env.NODE_ENV || 'N/A';
+    console.log(`ℹ️  Ambiente selecionado: ${currentEnv}`);
+}
+/**
+ * Verificar configuração do Playwright
+ */
+function checkPlaywrightConfig() {
+    console.log('ℹ️  === Configuração do Playwright ===');
+    const cwd = process.cwd();
+    const configFiles = ['playwright.config.ts', 'playwright.config.js'];
+    const configFile = configFiles.find((file) => fs.existsSync(path.join(cwd, file)));
+    if (configFile) {
+        console.log(`✅ Configuração encontrada: ${configFile}`);
+        try {
+            // Tentar ler algumas configurações básicas
+            const configPath = path.join(cwd, configFile);
+            const configContent = fs.readFileSync(configPath, 'utf-8');
+            // Extrair informações básicas via regex (simples)
+            const testDirMatch = configContent.match(/testDir:\s*['"`]([^'"`]+)['"`]/);
+            if (testDirMatch) {
+                console.log(`ℹ️   Diretório de testes: ${testDirMatch[1]}`);
+            }
+            const timeoutMatch = configContent.match(/timeout:\s*(\d+)/);
+            if (timeoutMatch) {
+                console.log(`ℹ️   Timeout global: ${timeoutMatch[1]}ms`);
+            }
+        }
+        catch (error) {
+            console.log('ℹ️   (Não foi possível ler detalhes da configuração)');
+        }
+    }
+    else {
+        console.warn('⚠️ Nenhuma configuração do Playwright encontrada');
+    }
+}