@silasfmartins/testhub 1.0.0

package/.github/copilot-instructions.md

@@ -0,0 +1,520 @@
+# AutoCore Hub - GitHub Copilot Instructions (MCP)
+
+Atualizado em: 2026-03-17  
+Versao: 2.7.44-r28
+
+Este arquivo e a **fonte de verdade** para regras do **MCP** (Model Context Protocol), uso de tools e integracoes (Playwright/Test Recovery/Teams relay).
+
+Nao documenta detalhes do **Portal/UI** nem changelog por versao. Para isso, use `AGENTS.md`/`CLAUDE.md`.
+
+## 0) Regras obrigatorias (sempre)
+
+1) **Sincronia de docs (obrigatorio):**
+- Se mudar qualquer regra/fluxo de MCP/tools, atualizar **no mesmo patch**:
+  - `.github/copilot-instructions.md`
+  - `AGENTS.md` + `CLAUDE.md` (raiz)
+  - `backend/*` e `packages/autocore-hub-mcp/*` quando afetados
+- O CI valida versao via `.github/scripts/check-doc-sync.sh` (este arquivo precisa conter `v2.7.44`).
+
+2) **Produtividade (mcp-estimative):**
+- Ao executar qualquer tool (MCP ou nao), registrar **1 tarefa por tool** via `mcp-estimative`:
+  - `ai_productivity_start_task` -> executar tool -> `ai_productivity_complete_task`
+  - Registrar inclusive em caso de erro/cancelamento.
+
+3) **Auto-normalize apos tool (obrigatorio):**
+- Apos executar qualquer tool que gere/edite codigo/arquivos, rodar `normalize_project` automaticamente.
+- Excecao: se a tool atual for `normalize_project`, nao rodar novamente.
+
+4) **Seguranca e privacidade (obrigatorio):**
+- Nunca expor segredos (URL/token/senha/headers sensiveis) em output/logs.
+- Nunca devolver ciphertext no formato `iv:tag:cipher`.
+- Em sistemas/ambientes privados, respeitar a politica de visibilidade (ver Secao 2).
+- Ao retornar URLs capturadas, mascarar query params sensiveis: `token`, `state`, `password`, `code`, `request_id`, etc.
+
+5) **Escolha de tool (obrigatorio):**
+- Se o usuario pedir explicitamente uma tool, executar **a tool pedida** primeiro.
+- Nao trocar automaticamente por outra tool sem justificativa tecnica clara.
+- Para resolver credenciais de sistema/ambiente, usar sempre `get_system_environment`.
+- `get_system_login_hints` e somente para selectors/hints de login (nao substitui consulta de credenciais).
+
+6) **UI sensivel de integracoes (obrigatorio):**
+- A aba de Apps do MCP (`/dashboard/mcp?activeTab=apps`) deve ser visivel somente para `admin`.
+- Para `manager`/`user`, esconder o trigger da aba e corrigir acesso direto por query string para `chat`.
+
+7) **Auto-fix XPath local-first (obrigatorio):**
+- `fix_xpath_in_attributes` deve executar primeiro no MCP local (maquina do usuario), nunca assumir escrita valida via backend remoto.
+- Fallback remoto so quando explicitamente habilitado (`ALLOW_REMOTE_AUTOFIX_FALLBACK=true`).
+- Em Windows, preservar `projectRoot` com barras invertidas (`C:\\...`) e suportar UNC (`\\\\servidor\\share`).
+- Framework deve aguardar confirmacao do auto-fix (sem `fire-and-forget`) e registrar sucesso/falha com base em `fileUpdated` e validacao em disco.
+- Para inferencia de arquivo/alvo, priorizar `attrCtx.methodName`/`attributesFile` capturados do stack (nao usar `CT` como `methodName` de locator).
+- Quando `className` vier de `Page*`, o MCP local deve tentar mapear para `Attributes*` e, se necessario, buscar por XPath em `src/attributes`, `src/pages` e `tests` antes de desistir.
+- O retorno de auto-fix deve comprovar escrita local (hash/bytes alterados + novo XPath presente) e marcar `success=false` quando a escrita nao for confirmada.
+
+8) **Metadata de recovery (CN/CT/usuario) obrigatoria:**
+- Enviar `testCaseName` (CN), `testCaseId` (CT), `testMethodName` e `executionSource` explicitamente no body de `analyze-failure` e `report-result`.
+- Em fallback, extrair CN/CT de `TestContext.testInfo.titlePath` (CN = penultimo, CT = ultimo item util) para evitar `N/D` no dashboard.
+- Sempre enviar headers de ator (`x-automation-user-*` + aliases); quando variaveis AUTOCORE_* estiverem vazias, usar fallback de runtime (ex.: `USERNAME` no Windows).
+
+9) **Portal Automation (obrigatorio):**
+- Fluxo WEB no Portal deve chamar `codegen` via MCP (`/mcp`), priorizando execucao local-first na maquina do usuario.
+- O `codegen` deve priorizar saida em padrao framework (`.spec.ts` + `src/pages` + `src/attributes`) por padrao; `playwright` puro fica apenas quando `codegenTarget` for explicitamente solicitado.
+- Se backend nao tiver acesso a URL alvo, nao bloquear criacao: manter recorder/codegen no MCP local do usuario.
+- Para sincronizacao de testes salvos por usuario, usar a tool `get_portal_saved_tests` (hash MCP como identidade).
+- No framework, preferir helper backend-first para `get_portal_saved_tests` e helper local-first para `run_local_npm_script`/`codegen`.
+- O framework deve conseguir ler `portalTests[].files`, `portalTests[].cts[].runScript` e `portalTests[].cts[].runCommand` para materializar arquivos locais e sugerir execucao.
+- Conversao API por URL no Portal deve usar `POST /mcp/portal/convert-api-url` (backend baixa spec e converte).
+- Fluxo API no Portal deve manter uma unica acao de geracao no CT (sem botoes duplicados para a mesma conversao) e aceitar URL ou upload de arquivo Swagger/OpenAPI no mesmo fluxo.
+- Fluxo de geracao por prompt no Portal deve cobrir `SSH`, `MOBILE` e `BANCO`, chamando `generate_test` com `testType` correspondente (`ssh`, `mobile`, `banco`).
+- Ambientes no Portal devem ser selecionados por lista (vinculada ao sistema escolhido), sem input livre.
+- Tela de automacao deve resolver `user_hash` automaticamente (`GET /mcp/hash` com fallback `POST /mcp/hash`) antes de bloquear o usuario por hash ausente.
+- Apos gerar codigo no Portal, perguntar se o usuario deseja executar localmente e usar `run_local_npm_script` (`npm run ui:<ambiente>`, `npm run test:<ambiente>`, `npm run ssh:<ambiente>`).
+- Cenarios salvos no Portal com `cenario_id` `portal-auto:*` devem expirar automaticamente em 1 dia (`DATA_RETENTION_PORTAL_SCENARIOS_DAYS`).
+- Na tela `/dashboard/automation/new`, sempre mostrar status de MCP local (`online`, `toolCount`, `playwrightInstalled`, `lastHeartbeat`) e orientar instalacao/start quando offline.
+- Na tela `/dashboard/automation/new`, destacar comandos de AutoStart sem admin para Windows usando Startup do usuario com execucao oculta (background, sem janela de terminal).
+- Se a tool exigir MCP local, retornar comandos de setup/start no erro (`installCommand`, `startCommand`) para UX guiada.
+- No salvamento de cenário (`/execucoes-cenarios`), `ambiente` deve representar **origem de execução** (`LOCAL` ou `AZURE`) e não o tipo de ambiente funcional (`PROD/UAT`), que deve ficar em `defaultEnvironment`.
+- Backend deve tolerar clientes legados sem `ambiente` no payload e assumir `LOCAL` por padrão para não quebrar o save do Portal.
+- Para execução Azure no Portal, gerar YAML com parâmetros padrão (`env`, `test`) + extras opcionais, com suporte a cron/schedule e modo suíte.
+
+10) **Bootstrap do MCP local pelo framework (obrigatorio):**
+- `McpLocalClient` deve tentar iniciar STDIO automaticamente em ordem:
+  1. `HUB_MCP_STDIO_BIN` (quando definido),
+  2. `autocore-hub-mcp` global,
+  3. `npx -y @silasfmartins/testhub-orchestrator-mcp --stdio`.
+- Em `tools/list`, expor somente `codegen`; manter `playwright_execute` apenas como alias de compatibilidade em `tools/call` (sem aparecer na listagem).
+- No `consumer-postinstall` do framework (Windows local), configurar AutoStart do MCP automaticamente apos a instalacao:
+  - usar Startup do usuario (`%APPDATA%\\...\\Startup`) sem depender de Task Scheduler,
+  - gerar launcher oculto (`autocore-orchestrator-mcp.vbs`) + runner (`autocore-orchestrator-mcp.cmd`),
+  - iniciar imediatamente via `wscript.exe` para rodar em background (sem abrir terminal visivel).
+- No `WebActions`, `withRecovery` possui guard de recursão (`_recoveryDepth` estático, máximo 1 nível). Recovery actions como `click_other` que chamam `WebActions.click()` não reentram em novo ciclo de recovery, evitando `RangeError: Maximum call stack size exceeded`.
+- No `WebActions`, a resolucao de XPath deve ser robusta em todos os metodos de interacao:
+  - esperar `attached` + `scrollIntoViewIfNeeded` antes de exigir visibilidade,
+  - tentar variantes de XPath (`normalizeAxis`, sem indices, `contains(@name/@id, ...)`) sem depender de AutoHealing,
+  - buscar em contexto atual, pagina principal e frames priorizando iframes visiveis,
+  - em `setText`, permitir `force=true` para campo invisivel porem habilitado,
+  - registrar no log o seletor/XPath efetivamente utilizado apos fallback.
+
+## 1) Conceitos MCP no AutoCore Hub
+
+- **MCP local (STDIO/CLI/IDE):** roda na maquina do usuario, com acesso a browser (Playwright) e filesystem local.
+- **Backend (Fastify):** expõe APIs, guarda documentos e fila; nao deve depender de internet do backend para automacao em URL interna do usuario.
+- **Contrato de hash MCP:** chamadas para `/mcp` devem enviar `user_hash` (query `?user_hash=` ou header `x-user-hash`). Fallback por JWT existe, mas envio explicito e obrigatorio no framework.
+- **Test Recovery:** o backend **nao faz fetch(url)**; para analisar falha precisa de `pageStructure`/`pageHtml` enviados pelo MCP local.
+- **Execucao vs visualizacao de segredos:**
+  - `get_system_environment` em modo de consulta (view) deve mascarar segredos quando o usuario nao pode ver.
+  - Fluxos internos de execucao podem usar credenciais sem exibir valores ao usuario.
+
+## 2) Sistemas, ambientes e credenciais (MCP)
+
+### 2.1 EnvironmentType (contrato)
+
+Usar **somente** estes valores quando for necessario selecionar ambiente:
+- `PROD`, `PREPROD`, `UAT`, `DEV`, `QA`, `ESTEIRA1`, `ESTEIRA2`, `PRODLIKE`
+
+### 2.2 Multiplas credenciais por ambiente
+
+- Um ambiente pode ter `credentials[]`.
+- Existe uma credencial **default** (suffix nulo) e credenciais com `suffix` (ex.: `PARCEIRO`).
+- Ao resolver credenciais para login/Playwright:
+  1) priorizar credencial default em `environment_credentials`
+  2) fallback legado em `environments.username/password` so quando necessario
+
+### 2.3 Privacidade (sistemas/ambientes privados)
+
+- Sistema privado: somente `admin`, dono do sistema e membros com `canManage=true` podem **ver** credenciais/variaveis sensiveis.
+- Ambiente privado em sistema publico: visibilidade sensivel e por membros do ambiente com `canManage=true`.
+- Usuario sem permissao:
+  - deve receber campos mascarados (`[oculto por permissao]`)
+  - deve receber orientacao de que pode **executar** sem ver os valores
+
+## 3) Rotina obrigatoria: Teams relay (`teams.flush`)
+
+### 3.1 Comportamento esperado
+
+- O MCP local deve executar `teams.flush` no startup e manter loop (default 60s).
+- O flush consome fila do backend (`/mcp/teams/pending`), envia para Teams (webhook/workflow) e faz ACK (`/mcp/teams/ack`).
+- Backend deve:
+  - remover itens `sent` imediatamente apos ACK
+  - descartar `pending` nao enviado com mais de 24h
+  - aplicar retry com backoff exponencial + jitter para itens `failed`
+  - usar status de fila: `pending` -> `processing` -> (`sent`|`failed`|`dead`)
+  - evitar loop infinito: circuit breaker por regra/webhook + dead-letter apos max tentativas
+  - quando a consulta da fila falhar, o MCP deve retornar diagnostico amigavel (sem stack) e sugerir checagens de migration/config (hotfix v2.7.44)
+  - `teams_flush` do backend (MCP HTTP) deve operar em **backend-first por padrão**: claim da fila e envio imediato do webhook no servidor.
+  - handoff local continua suportado quando `dispatchMode=local` (release para `pending` e envio via `teams.flush` local).
+
+### 3.2 Configuracao (variaveis)
+
+- `HUB_BACKEND_URL`
+- `HUB_MCP_USER_HASH`
+- `HUB_MCP_KEY` (ou `MCP_INTERNAL_KEY` / `TEAMS_RELAY_KEY`)
+- `HUB_TEAMS_FLUSH_ENABLED` (no MCP local, considerar habilitado por padrao)
+- `HUB_TEAMS_FLUSH_INTERVAL_MS` (default `15000`)
+- `HUB_TEAMS_FLUSH_LIMIT`
+- `HUB_TEAMS_FLUSH_IGNORE_SSL` (quando houver proxy/SSL corporativo)
+
+### 3.3 Troubleshooting do erro "fetch failed"
+
+Quase sempre e um destes:
+- SSL corporativo (cert auto-assinado): usar `HUB_TEAMS_FLUSH_IGNORE_SSL=true` e/ou `NODE_TLS_REJECT_UNAUTHORIZED=0` (com cautela)
+- No backend (`teams_flush` via MCP HTTP), usar `TEAMS_FLUSH_IGNORE_SSL=true` quando o relay rodar no servidor e houver inspeção TLS corporativa
+- timeout/rede instavel: aplicar retry com backoff e timeout por request
+- `HUB_BACKEND_URL` errado ou bloqueado por firewall
+- webhook PowerAutomate invalido/incompleto: validar URL completa (`https://.../workflows/.../triggers/manual/paths/invoke?...`)
+- quando o backend nao tiver rota de saida para o PowerAutomate, usar `dispatchMode=local` para forcar envio pela maquina do usuario.
+
+### 3.4 Teams Chat (bot) para conversar com MCP
+
+- O bot Teams deve encaminhar mensagens para `POST /mcp/integrations/teams/channel`.
+- O payload deve incluir identidade do usuario (`from.aadObjectId`/`from.id`) para manter conversa isolada por usuario.
+- Para onboarding dos usuarios no Teams, usar os endpoints:
+  - `GET /mcp/integrations/teams/links` (links de abrir app/chat)
+  - `GET /mcp/integrations/teams/package` (zip do app)
+  - `GET /mcp/integrations/teams/manifest` (manifest cru)
+- Quando `TEAMS_BOT_APP_ID`/`MicrosoftAppId` estiver configurado, o manifest deve incluir capability `bots` com escopos `personal` e `team`.
+- `GET /mcp/integrations/teams/links` deve expor status real (`appInstallReady`, `personalChatReady`, `isTemplateOnly`, `blockers`) para a UI nao sugerir chat funcional quando o tenant ainda nao foi preparado.
+
+## 4) Auto-normalize obrigatorio (`normalize_project`)
+
+### 4.1 Regra
+
+- Sempre rodar `normalize_project` depois de qualquer tool (exceto `normalize_project`).
+
+### 4.2 Correcoes minimas esperadas
+
+- Remover `await` indevido em `env.*`:
+  - `await env.CEP` -> `env.CEP`
+  - `await this.env.CEP` -> `this.env.CEP`
+- Scroll:
+  - `UtilsExt.scrollToByJS(...)` -> `await WebActions.scrollToElement(...)`
+  - nunca gerar `await await`
+- Windows paths: normalizar `C:\\...` quando `projectRoot` vier do Windows
+
+### 4.3 Variaveis do MCP local
+
+- `HUB_AUTO_NORMALIZE_AFTER_TOOL` (default `true`)
+- `HUB_AUTO_NORMALIZE_COOLDOWN_MS` (default `1000`)
+
+## 5) Tool: `generate_test` (reuso de contexto + motor de geração)
+
+### 5.1 Objetivo
+
+Gerar código de teste de forma consistente com o fluxo capturado, sistema/ambiente e flavor (Web/API/SSH/Banco/Mobile).
+
+### 5.1.1 Motor de geração de código (compartilhado com `codegen`)
+
+O `generate_test` e o `codegen` (via `codegen_export`) compartilham o mesmo motor (`generateMcpTest`) com builders por flavor:
+
+**Web (`buildWebTemplates`):**
+- Gera: `Attributes*.ts` (src/attributes) + `PagePlaywright*.ts` (src/pages) + `.spec.ts` (tests)
+- Nomes seguem padrão `PagePlaywright{Sistema}{Assunto}` (ex.: `PagePlaywrightSalesforceCliente`)
+- Nome do arquivo = nome da classe (ex.: `PagePlaywrightSalesforceCliente.ts`)
+- 30+ ações mapeadas para métodos reais do `WebActions`: click, setText, selectOption, hover, doubleClick, rightClick, checkCheckbox, uncheckCheckbox, scrollToElement, clearField, focus, setFiles, validateObject, validateObjectNotExists, validateEquals, takeScreenshot, getText, goBack, refresh, fixedWait, executeJavaScript, mouseMove, clickAndHold, selectDropdownOption, typeSlowly, pressKey, waitForVisible, waitForNetworkIdle, switchTo, switchToDefault
+- **Detecção de estágios:** `splitPagesByStage()` detecta transições automáticas de etapa por keywords nos elementos capturados (13 estágios: Login, Cliente, Endereço, Oportunidade, Cotação, Produto, Qualificação, Proposta, Pagamento, Envio, Contrato, Instalação) e gera Pages/Attributes separadas mesmo em SPAs onde a URL não muda
+- Auto-login: quando login automático ocorre, os passos (username/password/submit) são capturados e geram código de login automaticamente
+- Annotation: `TestAnnotations.Frontend.testInfo`
+
+**API (`buildApiTemplates`):**
+- Gera: `Request*.ts` (src/request) + `Statements*.ts` (src/statements) + `.spec.ts` (tests)
+- Usa métodos reais do `ApiActions`: get, post, put, patch, delete, validateEquals, validateNotNull, fixedWait, prepareContextWithCert, createFormData
+- Response tipada como `JsonResponse` com todos os métodos: getStatus, get, getString, getArray, getObject, getFromArray, getStringFromArray, getPath, getPathOrDefault, raw, hasKey, isEmpty, isXml, extractXml, equals
+- Request suporta `ApiRequestOptions` completo: headers, data (JSON body), form (x-www-form-urlencoded), params (query), timeout, certificate (mTLS via `createCertificate`)
+- Annotation: `TestAnnotations.Api.testInfo`
+
+**Banco (`buildBancoTemplates`):**
+- Gera: `Model*.ts` (src/models) + `Statements*Db.ts` (src/statements) + `.spec.ts` (tests)
+- Usa métodos reais do `BancoActions`: select, selectColumn, update, execute, executeQuery, executarQuery, validateEquals, esperarPorTempo, executarServico
+- Model gera queries SELECT/UPDATE/INSERT parametrizadas
+- Annotation: `TestAnnotations.Banco.testInfo`
+
+**Mobile (`buildMobileTemplates`):**
+- Gera: `PagePlaywright*.ts` (src/pages) + `.spec.ts` (tests)
+- Usa métodos reais do `MobileActions`: click, clickNative, clickByCoordinates, setText, setChar, getText, validateObject, validateObjectNotExist, validateEquals, isPresent, back, swipe, swipeUntilFind, getAttribute, switchToContext, capturarScreenshot, relaunchApp, executeScript, genericSwipeAndroid/iOS, genericSwipeUntilFindAndroid/iOS, clickOnObjectPresence
+- Locators com `ILocator` (android/ios separados)
+- Annotation: `TestAnnotations.Mobile.testInfo`
+
+**SSH (`buildSshTemplates`):**
+- Gera: `Statements*Ssh.ts` (src/statements) + `.spec.ts` (tests)
+- `SSHActions.write()` é a ação principal (envio de comandos)
+- Usa métodos reais do `SSHActions`: autoConnect, connectWithKey, connectWithPassword, write, read, writeAndReturnCommand, readOutputCommand, download, desconectar, validateContains, validateNotContains, validateMatches, validateContainsWithTimeout, validateContainsAll, validateContainsAny
+- Estrutura com métodos `conectar()`, `executarComandos()`, `validarResultados()`, `run()`
+- Annotation: `TestAnnotations.SSH.testInfo`
+
+### 5.2 Regra de inferencia de sistema/ambiente
+
+1) Se o prompt atual mencionar explicitamente (ex.: "use o sistema X" / "ambiente UAT"), usar.
+2) Se o prompt indicar continuidade (ex.: "fluxo anterior", "mesmo sistema"):
+   - reaproveitar contexto recente da conversa quando houver `conversationId` com `usePreviousContext=true`.
+3) Se nao houver contexto confiavel:
+   - nao forcar `systemName/environmentType` no teste.
+
+### 5.3 Reuso de elementos do fluxo (obrigatorio)
+
+1) Priorizar `elements` enviados explicitamente na tool.
+2) Se `elements` nao vier, reaproveitar `capturedElements` da sessao Playwright ativa (`codegen`).
+3) Se ainda nao houver elementos, inferir steps do prompt atual quando houver XPath/seletor explicito:
+   - extrair XPath e acao (`click`, `fill`, `check`, `uncheck`, `select`) por contexto da frase;
+   - quando acao for `fill`, tentar inferir valor (`valor`, `value`, `texto`) no mesmo trecho;
+   - ignorar XPaths que estejam em contexto de sugestao de recovery (`XPath sugerido`, `autohealing`, `falha no XPath`) para nao poluir o fluxo com seletores nao executados;
+   - normalizar `||` para `|` em XPath antes de gerar.
+4) Mesclar elementos inferidos sem duplicar os capturados da sessao.
+5) Quando houver `capturedElements`/`elements` confiaveis, priorizar o fluxo capturado em vez de contexto antigo de `pageCode` armazenado em memoria.
+6) Se o login foi executado automaticamente na sessao (`autoLogin`), os passos de login capturados (username/password/submit) devem entrar em `capturedElements` para o `generate_test` refletir esse fluxo.
+7) Se nao houver contexto confiavel de elementos, gerar teste sem inventar fluxo.
+
+## 6) Tool: `extract_page_structure` (auto-login resiliente)
+
+### 6.1 Regra principal
+
+Retornar a estrutura da **URL alvo** (pos-login), e nao persistir na tela de login.
+
+### 6.2 Estrategia de auto-login (quando `autoLogin=true`)
+
+1) Navegar para `url`.
+2) Detectar tela de login quando:
+   - URL aparenta login (`/login|signin|sso|auth|idp|oauth|saml|entrar/i`), **ou**
+   - existe `input[type=password]` e botao de submit.
+3) Resolver credenciais na ordem:
+   - `login.username/password` no payload
+   - credencial default via `get_system_environment` (quando houver `systemName/environmentType`)
+   - fallback legado (quando ainda existir)
+3.1) Resolver **login hints** (quando disponivel) para melhorar a selecao de campos/botoes:
+   - override no payload `login.*` (`loginUrl`, `ssoSelector`, `usernameSelector`, `passwordSelector`, `submitSelector`, `successUrl`, `successSelector`)
+   - hints persistidas no banco via tool `get_system_login_hints` (por `systemName/environmentType`)
+4) Selecionar inputs **interagiveis**:
+   - visivel, habilitado, nao `readonly`, nao `hidden`, nao placeholder mascarado (`***`, `N/D`)
+5) Preencher `username` e `password`.
+6) Clicar submit com fallback por texto/aria-label/title:
+   - `Entrar`, `Login`, `Enviar`, `Sign in`, `Continue`
+7) Se houver etapa intermediaria, clicar em:
+   - `Next`, `Continue`, `Avancar`, `Prosseguir`, `Concluir login`
+7.1) Se apos submit aparecer tela intermediaria de autorizacao (ex.: texto `login autorizado` / `authorization successful`), clicar automaticamente em botao de avancar/continuar/prosseguir (`button/a/role=button/input`) antes de concluir o login.
+7.2) Em headless, se o botao de avancar nao estiver visivel, tentar fallback por locator existente/interagivel (inclusive em frame/iframe) e clicar com estrategia forçada.
+8) Suporte a `iframe/frame`:
+   - varrer frames e tentar o mesmo fluxo dentro do frame certo.
+9) Confirmar sucesso:
+   - nao estar mais em tela de login (sem campo de password, sem erro de login, sem redirect de volta para `/login`) **e** sem etapa pendente de autorizacao/avanco.
+10) Persistencia de sessao:
+   - salvar `storageState` (cookies/localStorage) por sistema/ambiente para reduzir relogin em chamadas futuras.
+
+Observacao operacional:
+- Aplicar a mesma rotina de auto-login para `codegen` quando `autoLogin=true` na sessao/parametros.
+- Quando ja existir sessao ativa/logada, `extract_page_structure` deve preservar o contexto atual por padrao (`preserveContext=true`) e so iniciar fluxo do zero com `fromScratch/resetSession` explicito.
+
+### 6.3 Memoria de XPath (Redis + projeto)
+
+- `extract_page_structure` deve sempre:
+  1) coletar XPaths da estrutura atual (incluindo `xpathCandidates`);
+  2) consultar hints salvas no Redis por URL/host;
+  3) quando `projectRoot` estiver disponivel, buscar XPaths em arquivos `Attributes*` relacionados ao contexto da tela;
+  4) persistir novos hints no Redis para reuso futuro (tudo que for descoberto ou informado).
+  5) ao atender pedidos de “traga os XPaths desta pagina”, combinar `extract_page_structure` + leitura do Redis (`getDoc`/catalogo da URL) para responder com o maximo de XPaths ja conhecidos.
+- Sempre que houver botao de busca/filtro (ex.: `Pesquisar`), tentar revelar inputs dinamicos pos-clique e incluir esses campos na estrutura antes de finalizar a resposta.
+- Se o usuario informar `xpath`/`xpaths`/`xpathHints`, salvar no Redis com prioridade alta.
+- O output deve incluir bloco de `XPath hints (Redis)` para facilitar debug e reaproveitamento.
+
+### 6.4 Configuracao util
+
+- Se falhar em headless: usar `headless: false` ou `HUB_PLAYWRIGHT_HEADLESS=false`.
+- Cookies/sessao:
+  - `HUB_PLAYWRIGHT_STORAGE_DIR` (default `~/.autocore-hub/playwright-storage-state`)
+  - `HUB_PLAYWRIGHT_STORAGE_TTL_HOURS` (default `24`)
+- SSL corporativo:
+  - `HUB_CRAWLER_IGNORE_SSL=true` (ou `HUB_IGNORE_SSL=true`)
+  - `NODE_TLS_REJECT_UNAUTHORIZED=0` (ultimo recurso)
+
+## 7) Tool: `codegen` (Playwright assistido + CodeGen)
+
+- Usar quando precisa executar acoes (click/fill/navigate) antes de extrair estrutura.
+- Nunca vazar credenciais no output (saneamento obrigatorio).
+- Ao sugerir/gerar seletores, preferir estrategia de fallback com union `|`.
+- Para seletores XPath de input com `contains(...)` (ex.: `//input[contains(@title,'Pesquisa')]`), gerar candidatos equivalentes por `@title/@placeholder/@aria-label` e fallback por label associado.
+- Extração de estrutura deve priorizar coleta ampla de inputs (incluindo `role=searchbox/combobox/textbox` e campos interagiveis colapsados) para alimentar `generate_test` e auto-healing.
+- Ao receber `structure`, usar o mesmo motor de hints do `extract_page_structure` (coleta da estrutura + hints do Redis + hints de `Attributes*`) e persistir o resultado no Redis.
+- Seletores executados (`selector/selectors/xpath/xpaths`) devem ser aproveitados como hints candidatas quando forem XPath validas.
+- Toda acao executada (click/fill/select/press/etc.), seja por comando ou interacao manual no browser aberto, deve persistir o XPath resolvido no Redis associado a URL/host da pagina atual; usar o mesmo mecanismo de hints de `extract_page_structure`.
+- Quando o usuario pedir XPaths de uma pagina, usar o Redis (`getDoc`/catalogo da URL) alem do snapshot atual para responder.
+- Quando uma tool receber XPath explicito e a URL ainda nao estiver no cache, fazer ingest best-effort dessa URL e persistir os hints no Redis; priorizar hints com sucesso comprovado (score maior).
+- Codegen integrado: suportar `action=codegen|codegen_preview|codegen_export|codegen_to_framework` no `codegen`; gerar Playwright puro durante a navegação e permitir migrar para padrão framework via `generate_code`/`codegenTarget=framework|both`.
+- `codegen` e a tool primaria e unica exibida para Playwright/CodeGen.
+- `tools/list` deve sempre anunciar `codegen` (backend e MCP local), mesmo quando Playwright backend estiver desabilitado.
+- Abertura de browser UI (CodeGen/recorder) deve ocorrer na maquina do usuario via MCP local (`autocore-hub-mcp`); evitar executar sessao Playwright UI no backend remoto.
+- No backend MCP HTTP, execução Playwright deve permanecer desabilitada por padrão (`MCP_BACKEND_PLAYWRIGHT_ENABLED=false`/ausente); habilitar no servidor apenas por exceção operacional explícita.
+- Quando o backend MCP responder erro com `requiresLocalMcp=true`, o cliente/framework deve reenviar automaticamente a mesma chamada para o MCP local (sem pedir nova confirmação ao usuário).
+- Se `codegen`/`playwright_execute` for chamado no backend com Playwright backend desabilitado, o backend deve enfileirar reroute por `user_hash` e aguardar execução do MCP local automaticamente.
+- O backend nao deve bloquear reroute apenas por ausencia de heartbeat recente; deve enfileirar e aguardar o MCP local ate timeout.
+- O MCP local deve fazer polling de reroute (`mcp_local_reroute_poll`) e concluir resposta (`mcp_local_reroute_complete`) apos abrir/executar browser na maquina do usuario.
+- O backend pode anunciar `codegen` no `tools/list` por compatibilidade, mas o cliente deve tratar esse tool como **local-first** e rerotear quando o backend indicar `requiresLocalMcp=true`.
+- Manter paridade do schema de entrada entre `codegen` e `playwright_execute` (mesmos atalhos top-level -> `params` e mesmas aliases de ação).
+- Quando vier apenas `systemName`, assumir `environment=PROD` por padrao (sem bloquear pedindo ambiente).
+- Credenciais para `codegen/start/navigate` devem ser resolvidas via `get_system_environment` (credencial default quando usuario nao escolher outra).
+- `codegen action=start` deve iniciar browser local automaticamente quando nao existir sessao ativa; se ja existir sessao, reaproveitar o contexto atual.
+- Compatibilidade legada: aceitar `playwright_execute` internamente (sem anunciar no `tools/list`).
+- Recorder de codegen sempre inicia habilitado no `start`/`navigate` (CodeGen default ON); grava interacoes manuais no browser desde o comeco e so para quando o usuario mandar `codegen_record_stop/toggle` para OFF.
+- Recorder manual: suportar `action=codegen_record_start|codegen_record_status|codegen_record_stop|codegen_record_toggle|codegen_clear`; ao gerar (`codegen_preview`/`codegen_export`/`codegen`) sincronizar eventos gravados para `capturedElements`.
+- MCP local (`packages/autocore-hub-mcp`) deve aceitar `codegen_record_start|codegen_record_status|codegen_record_stop` e aliases comuns de digitacao (`codegen_start_recording`, `codegen_stop_recording`, `codegen_record_state`), evitando erro `-32601` por acao nao suportada.
+- Em erro TLS/certificado para Playwright, orientar explicitamente comando por SO para instalacao:
+  - macOS/Linux: `NODE_TLS_REJECT_UNAUTHORIZED=0 npx playwright install chromium`
+  - Windows PowerShell: `$env:NODE_TLS_REJECT_UNAUTHORIZED='0'; npx playwright install chromium`
+  - Windows CMD: `set NODE_TLS_REJECT_UNAUTHORIZED=0 && npx playwright install chromium`
+- Clientes que chamam MCP local por STDIO devem usar protocolo MCP oficial (`StdioClientTransport` / framing `Content-Length`), não newline JSON ad-hoc.
+- Sessao de CodeGen deve seguir a mesma regra de contexto: reusar sessao ativa por padrao e reiniciar so com `fromScratch=true`/`resetSession=true`.
+- Cada acao executada/capturada deve atualizar contexto no Redis com `recentActions + xpathHints` da pagina atual; quando houver hint Redis com sucesso previo, priorizar esse XPath antes de fallback generico.
+- API push de DOM para execucao sem acesso de rede no backend: `POST /api/page-structure/extract` (alias legado: `/api/xpath-catalog/extract`) recebe `pageHtml/pageStructure` + contexto atual do framework e devolve `elements + xpaths` + hints Redis sem `fetch(url)` remoto.
+- Manter contrato de ações e targets de codegen centralizado em `playwright-execute-contract` para evitar drift entre schema da tool e executor de ação.
+- `codegen action=start` no MCP local deve reutilizar sessao existente mesmo sem `params.url`; se nao houver sessao/URL/sistema, iniciar browser local em `about:blank` para manter UX sem bloqueio.
+- Framework/cliente deve expor dois caminhos claros:
+  - `callMcpToolLocalFirst` para `codegen`, `run_local_npm_script` e auto-fix local.
+  - `callMcpToolBackendFirst` para tools dependentes de storage/backend, como `get_portal_saved_tests`.
+
+### 7.3 Priorizacao de backlog (CodeGen P0)
+
+Ordem obrigatoria de implementacao no framework/cliente:
+1. `P0-1` local-first + reuso de sessao:
+   - `codegen start` abre browser local quando nao houver sessao;
+   - com sessao existente, sempre reutilizar por padrao;
+   - reroute automatico para MCP local quando backend retornar `requiresLocalMcp=true`.
+2. `P0-3` fechamento com AutoHealing:
+   - ao sucesso de recovery, chamar `fix_xpath_in_attributes` no MCP local;
+   - confirmar alteracao real no arquivo (`fileUpdated/filePath` + verificacao em disco);
+   - dedupe somente com resultado valido (nunca deduplicar resposta vazia/invalida).
+
+### 7.2 Auto-fix local (`fix_xpath_in_attributes`) - contrato de retorno
+
+- A tool deve retornar payload estruturado em `result.success/fileUpdated/filePath/nextAction/error`.
+- Para compatibilidade, pode incluir também `result.content[].text` com JSON serializado do mesmo payload.
+- Cliente/framework deve fazer parse nesta ordem:
+  1) campos estruturados de `result`;
+  2) fallback JSON em `content[].text`.
+- Não aplicar dedupe quando retorno vier vazio/inválido.
+- Auto-fix deve tolerar variação de aspas no XPath (`'`/`"`) entre payload e arquivo local; falha por mismatch de citação deve cair em fallback de comparação normalizada antes de retornar `manual_review`.
+
+## 7.1 Documentos MCP (fonte unica + auditoria)
+
+- A pagina de documentos do dashboard e a aba de documentos do MCP devem usar a mesma fonte `mcp_documents` (rotas `/mcp/documents` e `/mcp/admin/documents`), sem duplicar storage.
+- Documentos enviados em qualquer uma das telas devem aparecer automaticamente na outra, respeitando visibilidade (`isPublic`) e permissoes do usuario.
+- ACL obrigatoria:
+  - somente o dono do arquivo ou `admin` pode alterar visibilidade (`/mcp/documents/:id/visibility`) e excluir (`DELETE /mcp/documents/:id`);
+  - documento privado (`isPublic=false`) e visivel por padrao apenas para dono + admin;
+  - compartilhamento adicional por usuario e feito por `/mcp/documents/:id/sharing` (owner/admin), persistindo em `shared_with.users`.
+- Leitura de documento em `/mcp/documents/:id` deve registrar auditoria por usuario quando disponivel em `mcp_document_views` (contagem e ultimo acesso).
+- Endpoint admin para auditoria detalhada: `GET /mcp/documents/:id/views` (retorna leitores + quantidade de leituras por usuario).
+- Download de documento deve permanecer desabilitado por padrao (`MCP_DOCUMENTS_ALLOW_DOWNLOAD=false`), inclusive na UI, mantendo apenas leitura autenticada.
+- Para midias extraidas (`mcp_document_media.file_url`), o frontend deve resolver URL via backend (`getApiUrl`) para evitar quebra de imagem em dominios distintos.
+- UX atual: a central operacional de documentos fica em `/dashboard/documents`; a aba `documents` em `/dashboard/mcp` foi descontinuada e deve redirecionar para essa central.
+
+## 8) Test Recovery (contrato + fila + auto-fix)
+
+### 8.1 `POST /api/test-recovery/analyze-failure` (contexto rico)
+
+Enviar sempre que possivel:
+- `context.text`
+- `context.value`
+- `context.filledInputs`
+- `context.filledFields`
+- `context.originalMethod`
+- `testCaseName`/`testCaseId`/`testMethodName` (ou aliases `cn`/`ct`/`methodName`)
+- `executionSource` (`Local` ou `Azure`)
+- `pageStructure` (preferencial) ou `pageHtml` (fallback)
+
+Para rastreio correto de usuario no dashboard (evitar `PlaywrightFrame`):
+- enviar `x-automation-user-id` (preferencial), ou `x-automation-user-matricula`/`x-automation-user-email`
+- opcional: `x-automation-user-name`
+- aliases aceitos: `x-user-id`, `x-user-name`, `x-user-email`, `x-user-matricula`, `x-matricula`, `x-framework-user-*`
+- aliases de metadata aceitos: `x-test-name`, `x-test-id`, `x-cn-name`, `x-ct-id`, `x-method`, `x-execution-origin`
+
+Importante:
+- O backend **nao faz fetch(url)**; `pageStructure/pageHtml` devem vir do MCP local (`extract_page_structure`/`codegen`).
+
+### 8.2 Resposta `202` (fila assincrona)
+
+Se `analyze-failure` responder `202` com `requestId`:
+1) chamar `GET /api/test-recovery/queue/:requestId`
+2) aguardar status `completed`
+3) usar `responsePayload` como resposta final
+4) se `failed|timeout`, registrar falha e seguir fallback local
+
+Recomendacao operacional do framework:
+- polling total >= 90s (evitar timeout prematuro de 30s);
+- backoff curto progressivo (1s, 2s, 3s, 5s, 8s...);
+- para execucao `Local`/`framework`, o backend prioriza fast-path inline; ainda assim manter suporte ao fluxo `202`.
+
+### 8.3 `report-result` (historico consistente)
+
+- Sempre reportar sucesso **e** falha.
+- Priorizar `logId` quando existir.
+- `sessionId` e fallback e precisa ser estavel por execucao.
+- Reenviar `testCaseName`/`testCaseId`/`testMethodName` e `executionSource` no `report-result` para corrigir lacunas de metadata.
+- No `auto-fix-local`, enviar `projectRoot` absoluto sempre que possivel; se faltar, enviar fallback por header `x-project-root`.
+
+### 8.4 `actions[]` (inclui `switch_frame`)
+
+- Se vier `switch_frame`, alternar para o frame indicado, tentar `suggestedXPath/alternatives`, e voltar para default ao final.
+
+### 8.5 Estrategia de XPath (auto-healing)
+
+- Normalizar `||` -> `|`.
+- Preferir union `|` quando existir mais de uma forma plausivel:
+- `//span[text()='Avancar'] | (//span[text()='Avancar'])[2]`
+- Se XPath vier indexado e instavel (ex.: `(//button/span[text()='Avancar'])[2]`):
+  - tentar tambem a versao sem indice e escolher por **visibilidade/clickabilidade**.
+- Se XPath apontar para descendente nao clicavel (ex.: `//button/...//span[text()='Avancar']`):
+  - promover fallback para o pai clicavel (`//button[...]`) e combinar assinatura de classe + texto (`contains(@class, ...)` + `span[normalize-space(.)=...]`).
+- Drift simples de atributo (`id/name`): gerar fallbacks `starts-with` e `contains` para `@id` e `@name`, inclusive quando o XPath original ja usa `contains/starts-with` (cobre `id="user"` → `id="username"`).
+- Para inputs de pesquisa, incluir também fallbacks `contains(...)` para `@title`, `@placeholder` e `@aria-label`.
+- Checkboxes posicionais (ex.: `slds-checkbox_faux`):
+  - combinar fallback por indice + texto/label (`Principal`) quando aplicavel.
+
+## 9) Retencao de dados (storage) - impacto no MCP
+
+### 9.1 Worker automatico
+
+- O backend executa limpeza automatica no startup + intervalo.
+- Intervalo padrao do worker: `DATA_RETENTION_INTERVAL_MINUTES=480` (8 horas).
+
+### 9.2 Politica atual
+
+- `execucoes_artifacts`: **ate 8 horas** (`DATA_RETENTION_ARTIFACTS_HOURS`, max 8; fallback compativel via `DATA_RETENTION_ARTIFACTS_DAYS`)
+- `notificacoes`, `health_checks`, `mcp_conversations`: **5 dias** (`DATA_RETENTION_DAYS`, default 5)
+- `teams_notification_queue`: remover `sent` imediatamente; descartar `pending` com mais de 24h
+
+## 10) SSL corporativo (MCP local)
+
+Quando houver certificado auto-assinado:
+- Preferir `HUB_CRAWLER_IGNORE_SSL=true` / `HUB_IGNORE_SSL=true`
+- Ultimo recurso: `NODE_TLS_REJECT_UNAUTHORIZED=0`
+
+## 11) Tools MCP (nomes e parametros principais)
+
+Os nomes abaixo sao contratos. Manter compatibilidade retroativa quando possivel.
+
+- `migrate_java_file`: `{ javaCode, fileName, mode? }`
+- `generate_test`: `{ pageCode, pageClassName, testName, systemName?, environmentType?, conversationId?, usePreviousContext?, useCapturedElements?, elements?, flavor?, testType?, prompt?, reuseExistingFiles? }`
+  - `flavor`/`testType`: `web` (default), `api`, `banco`, `mobile`, `ssh` — seleciona o builder e padrão de código
+  - `elements`: `McpCapturedElement[]` — quando presente, gera código baseado nos elementos capturados (priorizando sobre prompt)
+  - Motor compartilhado com `codegen_export` via `generateMcpTest()`
+- `generate_test_example`: `{ ... }`
+- `search_documents`: `{ prompt, limit? }` (lista documentos MCP e retorna IDs relevantes)
+- `getDoc`: `{ id?, documentId?, name?, fileName?, url?, maxChars?, refresh?, syncPlaywright? }` (leitura de documento MCP por ID/nome; para URL delega ao cache do crawler)
+- `list_systems`: `{}`
+- `get_system_environment`: `{ systemName, environmentType?, accessMode? }` (`environmentType` opcional, default `PROD`)
+- `get_system_login_hints`: `{ systemName, environmentType? }` (`environmentType` opcional, default `PROD`)
+- Regra de uso: `get_system_environment` para URL/credenciais; `get_system_login_hints` apenas para selectors/hints de login.
+- `ingestUrl`: `{ url, includeScreenshot? }`
+- `extract_page_structure`: `{ url, autoLogin?, login?, headless?, ignoreSSL?, preserveContext?, keepContext?, includeRuntimeContext? }`
+- `crawler_getDoc`: `{ url, ... }` (leitura do cache Redis/crawler para URL ingerida)
+- `normalize_project`: `{ projectRoot, codeFileHints?, dryRun?, renameFiles?, updateImports?, updateClasses? }`
+- `convert_api_spec`: `{ content, type, mode, projectRoot }`
+- `get_portal_saved_tests`: `{ limit?, executionId?, systemName?, environment?, includeCode? }` (backend-first; retorna `portalTests[]` com `files`, `cts`, `runScript`, `runCommand`, `retention`)
+- `fix_xpath_in_attributes`: `{ projectRoot, oldXPath, newXPath, attributesFile?, className?, methodName?, confidence?, executionSource? }`
+- Para `fix_xpath_in_attributes`, priorizar MCP local via **STDIO direto**; usar bridge HTTP local (`127.0.0.1/localhost`) apenas se o framework optar por esse transporte; backend MCP remoto é fallback de compatibilidade.
+- `codegen`: `{ action?, params?, selector?, ref?, xpath?, locator?, codegenTarget? }` (tool primaria de Playwright/CodeGen, default `action=start`)
+  - `action=start|navigate|click|fill|select|codegen_export|codegen_preview|codegen_to_framework|...`
+  - `codegenTarget`: `framework` (default), `playwright`, `both` — ao exportar, `framework` gera Attributes+Pages+.spec.ts via `generateMcpTest()`
+  - `codegen_export` com `codegenTarget=framework` gera código no padrão do framework a partir dos elementos gravados, detectando estágios automaticamente (Login → Cliente → Oportunidade → etc.)
+  - Auto-login do Playwright é capturado em `capturedElements` e gera código de login automaticamente
+  - Nome do teste inferido de: `testName` explícito > título da página/URL > nome do sistema
+- `playwright_execute` (legado): manter apenas compatibilidade de chamada interna; nao anunciar em `tools/list`.
+- `run_local_npm_script`: `{ script, projectRoot?, timeoutMs? }` (local-first; executa `npm run <script>` na maquina do usuario)
+- `generate_bpmn_xml`: `{ processDescription }`
+- `teams.flush` (local): `{ limit?, dryRun?, ignoreSSL? }`

package/biome.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.4.7/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "includes": ["**", "!!**/dist"]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 320
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "semicolons": "asNeeded"
+    }
+  },
+  "assist": {
+    "enabled": true,
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @silasfmartins/testhub - Entry Point
+ *
+ * 🔧 AutoCore Hub - Framework de Automação Unificado
+ * Suporte completo para Web, Mobile, API, SSH, Banco e testes mistos
+ */
+import "./src/config/jest-safe-setup.js";
+import "./src/security/protector.js";
+import "./src/playwright/registerRecoveryWrappers.js";
+export type { ILocator, IPage } from "./src/interfaces.js";
+export { ApiActions, type ApiRequest } from "./src/api/ApiActions.js";
+export { JsonResponse } from "./src/api/JsonResponse.js";
+export { Direcao, MobileActions } from "./src/appium/MobileActions.js";
+export { MobileConnection } from "./src/appium/MobileConnection.js";
+export { BancoActions } from "./src/helpers/BancoActions.js";
+export { ParallelExecutionHelper } from "./src/helpers/ParallelExecutionHelper.js";
+export { WebActions } from "./src/playwright/WebActions.js";
+export { ActionTimeline, SelectorCache, RecoveryQueue, } from "./src/playwright/actions/index.js";
+export type { ClickOptions, FillOptions, SelectOptions, HoverOptions, ScreenshotOptions, ScrollOptions, KeyboardOptions, NavigationOptions, WaitOptions, ActionEvent, ActionEventType, ActionEventStatus, TimelineSummary, RecoveryQueueItem, } from "./src/playwright/actions/index.js";
+export { test, expect, NetworkLogger } from "./src/playwright/fixtures.js";
+export type { Page, TestInfo, BrowserContext, Browser, NetworkLogEntry, } from "./src/playwright/fixtures.js";
+export { default as NetworkLogsReporter } from "./src/playwright/network-logs-reporter.js";
+export { SSHActions } from "./src/ssh/SSHActions.js";
+export { SSHClient } from "./src/ssh/SSHClient.js";
+export { TestContext } from "./src/testContext/TestContext.js";
+export { UnifiedReportManager } from "./src/testContext/UnifiedReportManager.js";
+export { CoverageManager } from "./src/testContext/CoverageManager.js";
+export { Api, Auto, Banco, Frontend, Mixed, Mobile, SSH, TestAnnotations, } from "./src/testContext/TestAnnotations.js";
+export { cleanupEnvLock } from "./src/config/envLoader.js";
+export { DataStore } from "./src/utils/DataStore.js";
+export { Logger } from "./src/utils/Logger.js";
+export { default as globalSetup } from "./src/global-setup.js";
+export { resolveJestVitestConflict } from "./src/config/jest-safe-setup.js";
+export { TestHubVars } from "./src/testhub/TestHubVars.js";
+export { SyncSignal } from "./src/helpers/SyncSignal.js";
+export { TestRecoveryHelper, testRecoveryHelper, analyzeFailure, markSuccess, getRecoveryStats, getRecoveryLogs, getRecurringFailures, suggestRefactor, impactAnalysis, methodToActionType, inferActionType, isValidActionType, isValidErrorType, type ErrorType, type ActionType, type RecoveryRequest, type RecoveryResponse, type RecoveryContext, type PageElement, type AutoFixLocalRequest, type AutoFixLocalResponse, } from "./src/utils/testRecovery/TestRecoveryClient.js";
+export { ResilientPlaywright, capturePageHtml, captureScreenshotBase64, } from "./src/utils/testRecovery/ResilientPlaywright.js";
+export { teamsFlushAfterExecution } from "./src/utils/TeamsFlushHook.js";
+export { CodeGenSession, type RecordedEvent, type PlaywrightExecuteResult, type CodeGenSessionOptions, type CodegenTarget, type McpTransport, } from "./src/utils/CodeGenSession.js";
+export { XPathCatalog, type XPathCatalogItem, type CatalogGetOptions, type RawPageStructure, type CatalogExtractRequest, type CatalogExtractResponse, } from "./src/utils/XPathCatalog.js";
+export type { PageXPathItem } from "./src/playwright/WebActions.js";
+export { fixXPathViaLocalMcp, clearFixDedupeTracker, clearToolsListCache, callMcpToolLocalFirst, callMcpToolBackendFirst, getPortalSavedTests, runLocalNpmScriptViaMcp, type FixXPathInAttributesParams, type FixXPathInAttributesResult, type PortalSavedTestsParams, type PortalSavedTestsResult, type PortalSavedTestScenario, type PortalSavedTestCt, type PortalSavedTestFile, type RunLocalNpmScriptParams, type RunLocalNpmScriptResult, } from "./src/utils/McpLocalClient.js";
+/** Unified AutoCore API object */
+declare const AutoCoreUnified: Record<string, unknown>;
+export default AutoCoreUnified;