@silasfmartins/testhub 1.0.0

package/scripts/postinstall.ts

@@ -0,0 +1,605 @@
+// @ts-nocheck
+import { ensureInstallationKeys } from '../src/security/KeysManager.js'
+import { spawnSync } from 'node:child_process'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+// ✅ ESM Compatibility
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+/**
+ * PostInstall do AutoCore - APENAS configuração, SEM BUILD
+ */
+
+console.log('AutoCore: Iniciando PostInstall (configuração apenas)...')
+
+// ✅ Caracteres zero-width para marcadores invisíveis (igual ao HoneypotManager)
+const PROTECTION_MARKERS = '\u200B\u200C\u200D\uFEFF'
+
+// ✅ Injetar marcadores invisíveis em arquivos críticos (EXCETO JSON)
+function injectProtectionMarkers(filePath: string, content: string): string {
+  // ❌ NUNCA adicionar marcadores invisíveis em arquivos JSON
+  if (filePath.endsWith('.json')) {
+    return content // Retornar conteúdo sem marcadores para JSON
+  }
+
+  // Verificar se já tem marcadores
+  const hasMarkers = PROTECTION_MARKERS.split('').some((char) =>
+    content.includes(char),
+  )
+
+  if (hasMarkers) {
+    return content // Já protegido
+  }
+
+  // Adicionar marcadores invisíveis no início do arquivo (apenas para não-JSON)
+  return PROTECTION_MARKERS + content
+}
+
+// ✅ Proteger arquivos críticos do sistema
+async function protectCriticalFiles(): Promise<void> {
+  const criticalFiles = ['package.json', 'tsconfig.json', '.gitignore']
+
+  for (const fileName of criticalFiles) {
+    try {
+      const filePath = path.join(process.cwd(), fileName)
+
+      if (existsSync(filePath)) {
+        const content = readFileSync(filePath, 'utf8')
+        const protectedContent = injectProtectionMarkers(filePath, content)
+
+        if (protectedContent !== content) {
+          writeFileSync(filePath, protectedContent, 'utf8')
+          console.log(
+            `AutoCore: Marcadores de proteção adicionados a ${fileName}`,
+          )
+        }
+      }
+    } catch (error: unknown) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error)
+      console.warn(`AutoCore: Erro ao proteger ${fileName}:`, errorMessage)
+    }
+  }
+}
+
+// ✅ Configurar segurança SEM build
+async function setupSecurity() {
+  try {
+    // Apenas em ambiente de produção/build explícito
+    if (process.env.AUTOCORE_BUILD_SECURITY === 'true') {
+      console.log('AutoCore: Modo build detectado - configurando segurança...')
+      const keys = ensureInstallationKeys()
+      console.log(
+        `AutoCore: Chaves geradas - ID: ${keys.installId.substring(0, 8)}...`,
+      )
+    } else {
+      console.log('AutoCore: Configuração básica aplicada (sem build)')
+    }
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    console.warn('AutoCore: Aviso na configuração:', errorMessage)
+  }
+}
+
+// ✅ Atualizar .gitignore
+async function updateGitignoreWithProtections(): Promise<void> {
+  try {
+    const cwd = process.cwd()
+    const gitignorePath = path.join(cwd, '.gitignore')
+    const protectionEntries = [
+      '',
+      '# AutoCore Protection (gerado automaticamente)',
+      '.generated/',
+      '.rbqa/',
+      '.helpers/',
+      '.automation/',
+      '.rbqa-*',
+      '.test-automation.*',
+      '.appium-helpers.*',
+      '*.rbqa.json',
+      '*.protection.key',
+      '.install.lock',
+      '.build.lock',
+    ]
+
+    if (existsSync(gitignorePath)) {
+      const currentContent = readFileSync(gitignorePath, 'utf8')
+      if (!currentContent.includes('# AutoCore Protection')) {
+        const newContent =
+          currentContent + '\n' + protectionEntries.join('\n') + '\n'
+        writeFileSync(gitignorePath, newContent)
+        console.log('AutoCore: .gitignore atualizado')
+      }
+    } else {
+      writeFileSync(gitignorePath, protectionEntries.join('\n') + '\n')
+      console.log('AutoCore: .gitignore criado')
+    }
+  } catch {
+    // Falha silenciosa
+  }
+}
+
+// 🌐 Registry privado do Azure Artifacts (único registry para pacotes @rbqa)
+const AZURE_REGISTRY = 'https://pkgs.dev.azure.com/telefonica-vivo-brasil/_packaging/DevOps/npm/registry/'
+
+// 🔧 Executa comando npm com environment configurado
+function execNpmSync(args: string[], timeoutMs = 30000): { stdout: string; status: number | null } {
+  try {
+    const result = spawnSync('npm', args, {
+      stdio: 'pipe',
+      shell: true,
+      windowsHide: true,
+      timeout: timeoutMs,
+      env: { ...process.env, npm_config_registry: AZURE_REGISTRY }
+    })
+    return {
+      stdout: result.stdout?.toString() || '',
+      status: result.status
+    }
+  } catch {
+    return { stdout: '', status: null }
+  }
+}
+
+// ✅ Obter versão instalada globalmente do pacote MCP
+function getInstalledMcpVersion(): string | null {
+  try {
+    const result = execNpmSync(['list', '-g', '@silasfmartins/testhub-orchestrator-mcp', '--depth=0', '--json'])
+    if (result.status === 0) {
+      const data = JSON.parse(result.stdout)
+      return data.dependencies?.['@silasfmartins/testhub-orchestrator-mcp']?.version || null
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+// ✅ Verificar acesso ao registry e obter última versão do MCP
+function checkRegistryAndGetLatestVersion(): string | null {
+  try {
+    const result = execNpmSync(
+      ['view', '@silasfmartins/testhub-orchestrator-mcp', 'version', `--registry=${AZURE_REGISTRY}`],
+      30000
+    )
+    if (result.status === 0 && result.stdout.trim()) {
+      return result.stdout.trim()
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+// ✅ Verificar se o pacote @silasfmartins/testhub-orchestrator-mcp está instalado globalmente
+function checkGlobalMcpPackage(): boolean {
+  const result = execNpmSync(['list', '-g', '@silasfmartins/testhub-orchestrator-mcp', '--depth=0'])
+  return result.status === 0 && result.stdout.includes('@silasfmartins/testhub-orchestrator-mcp')
+}
+
+// ✅ Instalar ou atualizar pacote MCP globalmente
+// 🎯 COMPORTAMENTO:
+// - Se já está na última versão: NÃO reinstala
+// - Se versão antiga: atualiza automaticamente  
+// - Se não instalado: instala globalmente
+// - Se offline: usa versão local existente
+function installOrUpdateMcpPackage(): { installed: boolean; updated: boolean; version: string | null } {
+  console.log('AutoCore: ======================================================')
+  console.log('AutoCore: MCP - Verificando instalação global')
+  console.log('AutoCore: ======================================================')
+  
+  const installedVersion = getInstalledMcpVersion()
+
+  if (installedVersion) {
+    console.log(`AutoCore: Versão global instalada: ${installedVersion}`)
+  } else {
+    console.log('AutoCore: MCP não encontrado globalmente')
+  }
+  
+  // Verificar acesso ao registry e obter última versão
+  console.log('AutoCore: Verificando registry Azure Artifacts...')
+  const latestVersion = checkRegistryAndGetLatestVersion()
+  
+  if (!latestVersion) {
+    console.log('AutoCore: Sem acesso ao registry Azure Artifacts (modo offline)')
+    if (installedVersion) {
+      console.log(`AutoCore: Usando versão global existente: ${installedVersion} ✓`)
+      return { installed: true, updated: false, version: installedVersion }
+    }
+    console.log('AutoCore: MCP será executado via npx quando necessário')
+    return { installed: false, updated: false, version: null }
+  }
+  
+  console.log(`AutoCore: Última versão disponível: ${latestVersion}`)
+  
+  // Comparar versões se já instalado
+  if (installedVersion) {
+    if (installedVersion === latestVersion) {
+      console.log('AutoCore: MCP já está na última versão global - nada a fazer! ✓')
+      return { installed: true, updated: false, version: installedVersion }
+    }
+    
+    // Versão desatualizada - atualizar
+    console.log(`AutoCore: Atualizando MCP: ${installedVersion} → ${latestVersion}`)
+  } else {
+    console.log('AutoCore: Instalando MCP globalmente...')
+  }
+  
+  // Executar instalação/atualização
+  const installResult = execNpmSync(
+    ['install', '-g', `@silasfmartins/testhub-orchestrator-mcp@${latestVersion}`, `--registry=${AZURE_REGISTRY}`],
+    60000
+  )
+  
+  if (installResult.status === 0) {
+    const newVersion = getInstalledMcpVersion()
+    if (installedVersion) {
+      console.log(`AutoCore: MCP atualizado: ${installedVersion} → ${newVersion || latestVersion} ✓`)
+    } else {
+      console.log(`AutoCore: MCP instalado globalmente (v${newVersion || latestVersion}) ✓`)
+    }
+    console.log('AutoCore: Disponível para todos os projetos da máquina')
+    return { installed: true, updated: !!installedVersion, version: newVersion || latestVersion }
+  }
+  
+  console.warn('AutoCore: Falha ao instalar/atualizar MCP')
+  if (installedVersion) {
+    console.log(`AutoCore: Usando versão global existente: ${installedVersion}`)
+    return { installed: true, updated: false, version: installedVersion }
+  }
+  
+  console.log('AutoCore: MCP será executado via npx')
+  return { installed: false, updated: false, version: null }
+}
+
+// ✅ Extrair user_hash de uma URL existente
+function extractUserHash(url: string): string {
+  const match = url.match(/user_hash=([a-zA-Z0-9]+)/)
+  return match ? match[1] : ''
+}
+
+// ✅ Copiar copilot-instructions.md para .github/ do projeto consumidor
+async function copyCopilotInstructions(): Promise<void> {
+  try {
+    const cwd = process.cwd()
+    
+    // Se estiver em dist/scripts, subir dois níveis; senão, um nível
+    const isDist = __dirname.includes('dist')
+    const levelsUp = isDist ? '../..' : '..'
+    const sourceFile = path.join(__dirname, levelsUp, '.github', 'copilot-instructions.md')
+    
+    const targetDir = path.join(cwd, '.github')
+    const targetFile = path.join(targetDir, 'copilot-instructions.md')
+
+    // Verificar se o arquivo fonte existe no pacote
+    if (!existsSync(sourceFile)) {
+      console.log('AutoCore: copilot-instructions.md não encontrado no pacote')
+      console.log(`   Caminho: ${sourceFile}`)
+      return
+    }
+
+    // Criar a pasta .github se não existir
+    if (!existsSync(targetDir)) {
+      console.log('AutoCore: Criando a pasta .github...')
+      mkdirSync(targetDir, { recursive: true })
+    }
+
+    // Copiar o arquivo
+    const content = readFileSync(sourceFile, 'utf8')
+    writeFileSync(targetFile, content, 'utf8')
+    console.log('AutoCore: copilot-instructions.md copiado para .github/ ✓')
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    console.warn('AutoCore: Erro ao copiar copilot-instructions.md:', errorMessage)
+  }
+}
+
+// ✅ Criar ou validar o arquivo .vscode/mcp.json (preservando hashes existentes)
+async function ensureMcpConfig(): Promise<void> {
+  try {
+    const vscodeDir = path.join(process.cwd(), '.vscode')
+    const mcpFile = path.join(vscodeDir, 'mcp.json')
+
+    // Criar a pasta .vscode se não existir
+    if (!existsSync(vscodeDir)) {
+      console.log('AutoCore: Criando a pasta .vscode...')
+      mkdirSync(vscodeDir, { recursive: true })
+    }
+
+    // Instalar/atualizar o MCP apenas em CI (ex.: agentes Azure Pipelines).
+    // Em máquinas dos usuários, não instalar globalmente — usar `npx` quando necessário.
+    const isCiEnv =
+      process.env.AZURE_PIPELINES === 'true' ||
+      process.env.CI === 'true' ||
+      !!process.env.BUILD_BUILDID ||
+      !!process.env.SYSTEM_TEAMFOUNDATIONSERVERURI
+
+    const isWindows = process.platform === 'win32'
+
+    // Instalar/atualizar o MCP apenas em máquinas Windows locais (desenvolvedores).
+    // NÃO instalar em CI (ex.: Azure Pipelines Linux agents).
+    if (!isCiEnv && isWindows) {
+      console.log('AutoCore: Ambiente Windows local detectado - verificando/instalando MCP globalmente')
+      try {
+        installOrUpdateMcpPackage()
+      } catch (e) {
+        console.warn('AutoCore: Falha ao instalar/atualizar MCP:', e)
+        console.log('AutoCore: O MCP será executado via npx quando necessário')
+      }
+    } else if (isCiEnv) {
+      console.log('AutoCore: Ambiente CI detectado - ignorando instalação global do MCP (use npx)')
+    } else {
+      console.log('AutoCore: Ignorando instalação/atualização global do MCP (use npx quando necessário)')
+    }
+
+    // Configuração padrão
+    const defaultConfig = {
+      servers: {
+        'mcp-estimative': {
+          url: 'http://brtlvlty0559pl:8080/estimative/mcp?user_hash=',
+          type: 'http',
+        },
+        'autocore-orchestrator': {
+          command: 'npx',
+          args: ['-y', '@silasfmartins/testhub-orchestrator-mcp'],
+          env: {
+            HUB_BACKEND_URL: 'http://brtlvlty0559pl:3333',
+          },
+          type: 'stdio',
+        },
+      },
+      inputs: [],
+    }
+
+    if (existsSync(mcpFile)) {
+      // Arquivo existe - preservar hashes do usuário
+      const currentContent = JSON.parse(readFileSync(mcpFile, 'utf8'))
+      
+      // Preservar hash do mcp-estimative
+      let existingEstimativeHash = ''
+      if (currentContent.servers?.['mcp-estimative']?.url) {
+        existingEstimativeHash = extractUserHash(currentContent.servers['mcp-estimative'].url)
+      }
+
+      // Construir configuração atualizada preservando hashes
+      const updatedConfig = {
+        servers: {
+          'mcp-estimative': {
+            url: `http://brtlvlty0559pl:8080/estimative/mcp?user_hash=${existingEstimativeHash}`,
+            type: 'http',
+          },
+          'autocore-orchestrator': {
+            command: 'npx',
+            args: ['-y', '@silasfmartins/testhub-orchestrator-mcp'],
+            env: {
+              HUB_BACKEND_URL: 'http://brtlvlty0559pl:3333',
+            },
+            type: 'stdio',
+          },
+        },
+        inputs: currentContent.inputs || [],
+      }
+
+      writeFileSync(mcpFile, JSON.stringify(updatedConfig, null, 2))
+      
+      if (existingEstimativeHash) {
+        console.log('AutoCore: Arquivo mcp.json atualizado (hash mcp-estimative preservado) ✓')
+      } else {
+        console.log('AutoCore: Arquivo mcp.json atualizado ✓')
+      }
+    } else {
+      // Criar novo arquivo com configuração padrão
+      writeFileSync(mcpFile, JSON.stringify(defaultConfig, null, 2))
+      console.log('AutoCore: Arquivo mcp.json criado ✓')
+    }
+
+    // Mensagem sobre configuração do user_hash
+    console.log('')
+    console.log('AutoCore: 🔑 Para usar o MCP, configure seu user_hash:')
+    console.log('AutoCore:    - mcp-estimative: Adicione seu hash na URL em .vscode/mcp.json')
+    console.log('AutoCore:    - autocore-orchestrator: No Windows, defina a variável de ambiente')
+    console.log('AutoCore:      do usuário HUB_MCP_USER_HASH com seu hash e reinicie o VS Code.')
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    console.warn('AutoCore: Erro ao configurar mcp.json:', errorMessage)
+  }
+}
+
+// ✅ Verificar se o Playwright está instalado (para projetos Frontend/Scenarios)
+async function ensurePlaywrightInstalled(): Promise<void> {
+  try {
+    const cwd = process.cwd()
+    const pkgFile = path.join(cwd, 'package.json')
+    
+    if (!existsSync(pkgFile)) return
+    
+    const content = readFileSync(pkgFile, 'utf8')
+    const pkg = JSON.parse(content)
+    
+    // Verificar se é projeto Frontend ou Scenarios (tem @playwright/test nas dependências)
+    const hasPlaywright = 
+      pkg.dependencies?.['@playwright/test'] || 
+      pkg.devDependencies?.['@playwright/test'] ||
+      pkg.dependencies?.['@silasfmartins/testhub'] ||
+      pkg.devDependencies?.['@silasfmartins/testhub']
+    
+    // Determinar se devemos instalar browsers Playwright
+    // Prioridade 1: variável de ambiente PROJECT_TYPE (WEB/FRONTEND or SCENARIOS)
+    const projectTypeEnv = (process.env.PROJECT_TYPE || process.env.PROJECTTYPE || '').toUpperCase()
+    const isProjectTypeWebOrScenarios = projectTypeEnv === 'WEB' || projectTypeEnv === 'FRONTEND' || projectTypeEnv === 'SCENARIOS'
+
+    // Fallback: Verificar se tem scripts de frontend/scenarios (indica que precisa de browsers)
+    const hasFrontendScripts =
+      !!pkg.scripts?.['test:preprod']?.includes('playwright test') ||
+      !!pkg.scripts?.['ui:preprod'] ||
+      !!pkg.scripts?.['codegen:preprod']
+
+    // Só instalar se o projeto for Web/Frontend ou Scenarios (por env ou por scripts indicativos)
+    if (!hasPlaywright || !(isProjectTypeWebOrScenarios || hasFrontendScripts)) return
+    
+    // Verificar se os browsers já estão instalados em vários locais comuns
+    function browsersPresent(dir: string): boolean {
+      try {
+        if (!existsSync(dir)) return false
+        const stat = require('node:fs').statSync(dir)
+        return !!stat
+      } catch {
+        return false
+      }
+    }
+
+    const possiblePaths = [
+      path.join(cwd, 'node_modules', '.cache', 'ms-playwright'),
+      path.join(cwd, 'node_modules', 'playwright-core', '.local-browsers'),
+      path.join(cwd, 'node_modules', 'playwright', '.local-browsers'),
+      path.join(cwd, 'node_modules', '.playwright'),
+      path.join(cwd, 'node_modules', 'playwright-core', '.playwright'),
+    ]
+
+    const browsersInstalled = possiblePaths.some(browsersPresent)
+
+    if (browsersInstalled) {
+      console.log('AutoCore: Browsers Playwright já instalados ✓')
+      return
+    }
+
+    // Tentar instalar browsers Playwright com tentativas e flags úteis
+    console.log('AutoCore: Browsers Playwright não encontrados. Tentando instalar...')
+
+    const installCommands = [
+      { args: ['playwright', 'install', '--with-deps'], desc: 'install --with-deps' },
+      { args: ['playwright', 'install'], desc: 'install' },
+      { args: ['playwright', 'install', '--force'], desc: 'install --force' },
+    ]
+
+    let installed = false
+
+    for (const cmd of installCommands) {
+      try {
+        console.log(`AutoCore: Executando: npx ${cmd.args.join(' ')} (cwd=${cwd})`)
+        const result = spawnSync('npx', cmd.args, {
+          stdio: 'pipe',
+          shell: true,
+          windowsHide: true,
+          cwd,
+          timeout: 300000, // 5 minutos
+        })
+
+        if (result.status === 0) {
+          // Rechecar se os browsers foram instalados
+          const nowInstalled = possiblePaths.some(browsersPresent)
+          if (nowInstalled) {
+            console.log(`AutoCore: Browsers Playwright instalados com sucesso (${cmd.desc}) ✓`)
+            installed = true
+            break
+          } else {
+            console.log(`AutoCore: Comando '${cmd.desc}' finalizou sem erro, mas browsers não foram detectados. Tentando próxima opção...`)
+          }
+        } else {
+          console.warn(`AutoCore: Comando 'npx ${cmd.args.join(' ')}' falhou com código ${result.status}`)
+        }
+      } catch (err) {
+        console.warn(`AutoCore: Erro ao executar 'npx ${cmd.args.join(' ')}': ${err}`)
+      }
+    }
+
+    if (!installed) {
+      console.warn('AutoCore: Falha ao instalar browsers Playwright automaticamente')
+      console.log('AutoCore: Instrução: execute manualmente: npx playwright install')
+    }
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    console.warn('AutoCore: Erro ao verificar Playwright:', errorMessage)
+  }
+}
+
+// ✅ Função principal async
+async function main() {
+  // ✅ PRIMEIRO: Proteger arquivos críticos
+  await protectCriticalFiles()
+
+  try {
+    // ✅ Configurar scripts de proteção (SEM executar)
+    const cwd = process.cwd()
+    const pkgFile = path.join(cwd, 'package.json')
+
+    if (existsSync(pkgFile)) {
+      const content = readFileSync(pkgFile, 'utf8')
+      const pkg = JSON.parse(content)
+      pkg.scripts ||= {}
+
+      const loaderFlag =
+        '--loader ./node_modules/@silasfmartins/testhub/protect-loader.mjs'
+
+      const ensurePre = (key: string) => {
+        const pre = `pre${key}`
+        const current = pkg.scripts[pre] as string | undefined
+        if (current?.includes(loaderFlag)) return
+
+        const exportCmd =
+          process.platform === 'win32'
+            ? `set NODE_OPTIONS=%NODE_OPTIONS% ${loaderFlag}`
+            : `export NODE_OPTIONS="$NODE_OPTIONS ${loaderFlag}"`
+
+        pkg.scripts[pre] = current ? `${exportCmd} && ${current}` : exportCmd
+      }
+
+      // Configurar proteção apenas para scripts específicos
+      ;['test', 'build'].forEach(ensurePre)
+
+      // Atualizar .gitignore
+      await updateGitignoreWithProtections()
+
+      // ✅ Salvar com marcadores de proteção
+      const newContent = JSON.stringify(pkg, null, 2)
+      const protectedContent = injectProtectionMarkers(pkgFile, newContent)
+      writeFileSync(pkgFile, protectedContent)
+      console.log('AutoCore: Scripts de proteção configurados')
+    }
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    console.warn('AutoCore: Erro na configuração de scripts:', errorMessage)
+  }
+
+  // ✅ Verificar smart-override usando binário
+  try {
+    const result = spawnSync('npx', ['autocore-sync', 'check', '--quiet'], {
+      stdio: 'pipe',
+      shell: true,
+      windowsHide: true,
+    })
+
+    if (result.status === 0) {
+      console.log('AutoCore: Smart-override verificado')
+    }
+  } catch (e) {
+    // Ignorar erro se binário não existir ainda
+  }
+
+  // ✅ Configurar segurança (SEM BUILD)
+  await setupSecurity()
+
+  // ✅ Criar ou validar o arquivo .vscode/mcp.json
+  await ensureMcpConfig()
+
+  // ✅ Copiar copilot-instructions.md para .github/
+  await copyCopilotInstructions()
+
+  // ✅ NOVO: Verificar e instalar Playwright para projetos Frontend/Scenarios
+  await ensurePlaywrightInstalled()
+
+  // ✅ FINAL: Re-proteger após modificações
+  await protectCriticalFiles()
+
+  console.log('AutoCore: PostInstall concluído SEM build!')
+}
+
+// ✅ Executar função principal (SEM BUILD)
+main().catch((error: unknown) => {
+  const errorMessage = error instanceof Error ? error.message : String(error)
+  console.warn('AutoCore: PostInstall falhou:', errorMessage)
+  // Não falhar o processo - apenas avisar
+})