opf-br-mcp 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 José Rogério
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# opf-br-mcp
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
+[![npm](https://img.shields.io/npm/v/opf-br-mcp.svg)](https://www.npmjs.com/package/opf-br-mcp)
+
+MCP server local que dá a agentes de codificação (Claude Code, GitHub Copilot)
+acesso token-eficiente às regras do Open Finance Brasil.
+
+## Domínios disponíveis
+
+| Domínio | Fonte | Conteúdo |
+|---|---|---|
+| `pcm-additional-info` | Confluence público OFB | Regras de obrigatoriedade do `additionalInfo` (PCM) |
+| `payments-v4-openapi` | GitHub OpenBanking-Brasil/openapi | Spec OpenAPI 4.0.0 da API de Pagamentos |
+| `payments-v5-openapi` | GitHub OpenBanking-Brasil/all-services-repo | Spec OpenAPI 5.0.0 da API de Iniciação de Pagamentos (consentimentos + Pix) |
+| `enrollments-v2-openapi` | GitHub OpenBanking-Brasil/all-services-repo | Spec OpenAPI 2.2.0 da API de Vínculo de Dispositivo (Enrollments, FIDO, Pix Automático) |
+| `automatic-payments-v2-openapi` | GitHub OpenBanking-Brasil/all-services-repo | Spec OpenAPI 2.2.0 da API de Pagamentos Automáticos (Pix Automático e Transferências Inteligentes) |
+| `consents-v3-openapi` | GitHub Pages openbanking-brasil.github.io | Spec OpenAPI 3.3.1 da API de Consentimentos (Dados Cadastrais e Transacionais) |
+| `pcm-openapi` | GitHub OpenBanking-Brasil/pcm-specs | Spec OpenAPI da PCM (reportes, hybrid-flow, opendata, consents/stock, credit-portabilities, payments/status) |
+| `pcm-business-rules` | Confluence público OFB | Regras de negócio da PCM (Reporte, Processamento, Divergências, Especificação Técnica, Manual de Integração) — item por seção |
+| `jornada-otimizada` | Confluence público OFB | Regras da Jornada Otimizada (Orientações Gerais, Transferências Inteligentes, Jornada sem Redirecionamento) — item por seção |
+| `mqd` | Confluence público OFB | Motor de Qualidade de Dados (Especificação Técnica, Arquitetura, Documentação da API, Manual de Instalação, Endpoints Validados, FAQ, Troubleshooting) — item por seção |
+| `webhook-v1-openapi` | GitHub OpenBanking-Brasil/all-services-repo | Spec OpenAPI 1.3.0 da API de Webhook (notificações de mudança de estado: pagamentos, enrollments, pagamentos automáticos) |
+| `seguranca` | Confluence público OFB | Segurança do Open Finance Brasil (Perfil de Segurança, FAPI, DCR, CIBA, Padrão de Certificados, Assinaturas, Casos de Erro, Redirecionamento App-to-App, Glossário, Versionamento) — item por seção |
+| `participantes` | Diretório OFB (data.directory.openbankingbrasil.org.br) | Organizações participantes, marcas (authorisation servers) e famílias de API suportadas com versões — um item por organização |
+| `portal` | Confluence público OFB (busca ao vivo) | Busca CQL em todo o Portal do Desenvolvedor (espaço OF) — sem cache, `query` obrigatória; fallback quando os domínios específicos não cobrem o assunto |
+
+## Tools
+
+- `list_domains()` — descoberta: domínios, filtros e estado do cache
+- `search(domain, query?, filters?, limit?, offset?)` — busca filtrada, retorno compacto
+- `get_item(domain, id)` — registro completo
+- `refresh(domain?)` — força re-extração das fontes
+
+Fluxo recomendado para o agente: `list_domains` → `search` → `get_item`.
+
+Domínios marcados como `live` (ex.: `portal`) consultam a fonte a cada chamada:
+não têm cache nem `refresh`, e `search` exige `query`. Quando um `search` em
+domínio comum retorna 0 resultados, a resposta inclui um `hint` sugerindo o
+`portal`.
+
+## Progressive disclosure (por que economiza contexto)
+
+O problema que este servidor resolve: uma spec Swagger/OpenAPI inteira não cabe
+bem na janela de contexto de um agente, e despejá-la desperdiça tokens. A solução
+é **revelação progressiva** — o agente nunca recebe a spec completa de uma vez,
+apenas o mínimo necessário em cada etapa do funil:
+
+1. **`list_domains`** — catálogo barato: quais domínios e filtros existem.
+2. **`search`** — índice **pesquisável e resumido**. Cada resultado traz só
+   `id`, `path`, `method`, `summary`/`name` e `required`; o nó pesado da spec
+   (`detail`) é removido do resumo, e o retorno ainda é compactado (omite `null`
+   e arrays vazios).
+3. **`get_item`** — só aqui o nó integral da spec é entregue, e apenas para o
+   `id` que o agente escolheu.
+
+Como o Swagger/OpenAPI vira dados pesquisáveis: o parser "achata" a spec em itens
+com `id` estável — um por endpoint (`type: operation`, ex.
+`payments-v4:POST /pix/payments`) e um por schema (`type: schema`, ex.
+`payments-v4:schema:PixPayment`). O JSON completo de cada nó fica retido em
+`detail` até um `get_item` explícito. Os `id`s não são adivinháveis: sempre vêm
+de um `search`. Assim o agente localiza o endpoint/schema certo pagando poucos
+tokens e só "paga" o payload integral quando pede um item nomeado.
+
+Dados: extraídos das fontes públicas na primeira consulta (lazy), cache em
+`~/.cache/opf-br-mcp/` com TTL de 24h. Sem rede, serve cache expirado com aviso.
+
+## Instalação
+
+Requer Node >= 20. O servidor roda via `npx`, sem clone nem build.
+
+Claude Code — `.mcp.json` na raiz do projeto consumidor:
+
+```json
+{ "mcpServers": { "opf-br": { "command": "npx", "args": ["-y", "opf-br-mcp"] } } }
+```
+
+GitHub Copilot (VS Code) — `.vscode/mcp.json`:
+
+```json
+{ "servers": { "opf-br": { "command": "npx", "args": ["-y", "opf-br-mcp"] } } }
+```
+
+### Uso local (a partir do fonte)
+
+```bash
+git clone https://github.com/jrogeriosilva/opf-br-mcp.git && cd opf-br-mcp
+npm install && npm run build
+```
+
+E aponte o client para o build local:
+
+```json
+{ "mcpServers": { "opf-br": { "command": "node", "args": ["/caminho/para/opf-br-mcp/dist/index.js"] } } }
+```
+
+## Adicionando um domínio novo
+
+1. Criar `src/domains/<id>/index.ts` exportando um objeto `Domain`
+   (`src/core/types.ts`): `extract()` busca e estrutura os dados;
+   `search`/`getItem` consultam; `filters` documenta os filtros.
+2. Registrar em `src/core/registry.ts`.
+3. Adicionar fixture e builder em `test/contract.test.ts` — a suíte de
+   conformidade valida o contrato automaticamente.
+
+## Desenvolvimento
+
+```bash
+npm test           # vitest (fixtures locais, sem rede)
+npm run typecheck  # tsc --noEmit
+npm run build      # tsup → dist/
+```

package/dist/index.js

@@ -0,0 +1,1185 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/core/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+// src/core/cache.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function cacheDir() {
+  const base = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
+  return join(base, "opf-br-mcp");
+}
+function cachePath(domainId) {
+  return join(cacheDir(), `${domainId}.json`);
+}
+function readCache(domainId) {
+  const path = cachePath(domainId);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeCache(domainId, data, packageVersion) {
+  const entry = {
+    extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    packageVersion,
+    data
+  };
+  mkdirSync(cacheDir(), { recursive: true });
+  const finalPath = cachePath(domainId);
+  const tmpPath = `${finalPath}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(entry));
+  renameSync(tmpPath, finalPath);
+  return entry;
+}
+function isFresh(entry, ttlHours, now = /* @__PURE__ */ new Date()) {
+  const age = now.getTime() - new Date(entry.extractedAt).getTime();
+  return age < ttlHours * 36e5;
+}
+
+// src/core/version.ts
+var PACKAGE_VERSION = "0.4.0";
+
+// src/core/data.ts
+async function getDomainData(domain, force = false, ctx) {
+  const cached = readCache(domain.id);
+  if (!force && cached && cached.packageVersion === PACKAGE_VERSION && isFresh(cached, domain.ttlHours)) {
+    return { data: cached.data, extractedAt: cached.extractedAt, stale: false };
+  }
+  try {
+    const data = await domain.extract(ctx);
+    const entry = writeCache(domain.id, data, PACKAGE_VERSION);
+    return { data, extractedAt: entry.extractedAt, stale: false };
+  } catch (err) {
+    if (cached) {
+      return { data: cached.data, extractedAt: cached.extractedAt, stale: true };
+    }
+    throw err;
+  }
+}
+
+// src/core/http.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchWithRetry(url, opts) {
+  let lastError;
+  for (let attempt = 0; attempt <= opts.retryDelaysMs.length; attempt++) {
+    if (opts.signal?.aborted) break;
+    if (attempt > 0) await sleep(opts.retryDelaysMs[attempt - 1]);
+    const timeout = AbortSignal.timeout(3e4);
+    const signal = opts.signal ? AbortSignal.any([opts.signal, timeout]) : timeout;
+    let response;
+    try {
+      response = await fetch(url, { headers: opts.headers, signal });
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      continue;
+    }
+    if (response.ok) return response;
+    lastError = new Error(`HTTP ${response.status} ${response.statusText} for ${url}`);
+    if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+      throw lastError;
+    }
+  }
+  throw lastError ?? new Error(`requisi\xE7\xE3o cancelada: ${url}`);
+}
+
+// src/core/text.ts
+function normalize(s) {
+  return s.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
+}
+function matchesQuery(haystack, query) {
+  const h = normalize(haystack);
+  return query.split(/\s+/).filter(Boolean).every((term) => h.includes(normalize(term)));
+}
+
+// src/domains/pcm-additional-info/config.ts
+var pcmConfig = {
+  confluenceBaseUrl: "https://openfinancebrasil.atlassian.net",
+  interRequestDelayMs: 2e3,
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3],
+  pages: [
+    { pageId: "1621622796", title: "Inicia\xE7\xE3o de Pagamentos" },
+    { pageId: "1623162886", title: "Inicia\xE7\xE3o de Pagamentos Sem Redirecionamento" },
+    { pageId: "1622081540", title: "Pagamentos Autom\xE1ticos" },
+    { pageId: "1212153857", title: "Regras de Obrigatoriedade additionalInfo - SG" },
+    { pageId: "1621786627", title: "DC - C\xE2mbio" },
+    { pageId: "1622736899", title: "DC - Cart\xE3o de Cr\xE9dito" },
+    { pageId: "1622474756", title: "DC - Consentimento" },
+    { pageId: "1623195649", title: "DC - Contas" },
+    { pageId: "1622212611", title: "DC - Dados Cadastrais" },
+    { pageId: "1623130114", title: "DC - Investimentos" },
+    { pageId: "1620181433", title: "DC - Opera\xE7\xF5es de Cr\xE9dito" },
+    { pageId: "1623293953", title: "DC - Recursos" }
+  ]
+};
+
+// src/core/confluence.ts
+var HEADERS = {
+  "User-Agent": "Mozilla/5.0 (compatible; opf-br-mcp/0.1; +opf-br-mcp)",
+  Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+  "Accept-Charset": "UTF-8",
+  "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8"
+};
+async function fetchConfluencePage(baseUrl, pageId, retryDelaysMs, signal) {
+  const apiUrl = `${baseUrl}/wiki/rest/api/content/${pageId}?expand=body.view`;
+  const response = await fetchWithRetry(apiUrl, { retryDelaysMs, headers: HEADERS, signal });
+  const json = await response.json();
+  return {
+    html: json.body?.view?.value ?? "",
+    title: json.title,
+    url: `${baseUrl}/wiki${json._links?.webui ?? ""}`
+  };
+}
+
+// src/domains/pcm-additional-info/parser.ts
+import * as cheerio from "cheerio";
+var ARRAY_FIELDS = /* @__PURE__ */ new Set([
+  "metodos",
+  "dominio",
+  "endpoints",
+  "versoes"
+]);
+var DIACRITICS_REGEX = /[̀-ͯ]/g;
+function toCamelCase(text2) {
+  return text2.normalize("NFD").replace(DIACRITICS_REGEX, "").replace(/[^a-zA-Z0-9\s]/g, "").trim().split(/\s+/).map(
+    (word, i) => i === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+  ).join("");
+}
+function normalizeHeader(raw) {
+  const lower = raw.trim().toLowerCase().normalize("NFD").replace(DIACRITICS_REGEX, "");
+  const known = {
+    "campo": "campo",
+    "definicao": "definicao",
+    "regra de preenchimento": "regraDePreenchimento",
+    "roles": "roles",
+    "http code": "httpCode",
+    "httpcode": "httpCode",
+    "metodos": "metodos",
+    "metodo": "metodos",
+    "dominio": "dominio",
+    "endpoints": "endpoints",
+    "endpoint": "endpoints",
+    "versoes": "versoes",
+    "versao": "versoes",
+    "tamanho maximo": "tamanhoMaximo",
+    "padrao": "padrao",
+    "exemplo": "exemplo"
+  };
+  if (known[lower]) return known[lower];
+  return toCamelCase(raw);
+}
+function splitArrayValue(value, key) {
+  if (!value.trim()) return [];
+  const parts = value.split(/[\n,]+/).map((p) => p.trim()).filter(Boolean);
+  if (key === "endpoints") {
+    const result = [];
+    for (const part of parts) {
+      if (part.startsWith("/")) {
+        result.push(part);
+      } else {
+        result.push(...part.split(/\s+/).filter((t) => t.startsWith("/")));
+        const nonPaths = part.split(/\s+/).filter((t) => !t.startsWith("/") && t.length > 0);
+        result.push(...nonPaths);
+      }
+    }
+    return result.filter(Boolean);
+  }
+  if (key === "metodos" || key === "dominio" || key === "versoes") {
+    const result = [];
+    for (const part of parts) {
+      result.push(...part.split(/\s+/).filter(Boolean));
+    }
+    return result;
+  }
+  return parts;
+}
+function cellText($, el) {
+  const clone = $(el).clone();
+  clone.find("br").replaceWith("\n");
+  return clone.text().replace(/ /g, " ").trim();
+}
+function parseAdditionalInfoTables(html) {
+  const $ = cheerio.load(html);
+  const fields = [];
+  $("table").each((_, table) => {
+    const rows = $(table).find("tr").toArray();
+    if (rows.length < 2) return;
+    const headerRow = rows[0];
+    const rawHeaders = $(headerRow).find("th, td").toArray().map((th) => cellText($, th));
+    if (rawHeaders.length === 0 || rawHeaders.every((h) => !h)) return;
+    const headers = rawHeaders.map(normalizeHeader);
+    if (!headers.includes("campo")) return;
+    for (let i = 1; i < rows.length; i++) {
+      const cells = $(rows[i]).find("td").toArray();
+      if (cells.length === 0) continue;
+      const field = {
+        campo: null,
+        definicao: null,
+        regraDePreenchimento: null,
+        roles: null,
+        httpCode: null,
+        metodos: [],
+        dominio: [],
+        endpoints: [],
+        versoes: [],
+        tamanhoMaximo: null,
+        padrao: null,
+        exemplo: null
+      };
+      cells.forEach((cell, colIdx) => {
+        const key = headers[colIdx];
+        if (!key) return;
+        const text2 = cellText($, cell);
+        const isEmpty = text2 === "" || text2 === "-" || text2 === "\u2014";
+        if (ARRAY_FIELDS.has(key)) {
+          field[key] = isEmpty ? [] : splitArrayValue(text2, key);
+        } else {
+          field[key] = isEmpty ? null : text2;
+        }
+      });
+      fields.push(field);
+    }
+  });
+  return fields;
+}
+
+// src/domains/pcm-additional-info/index.ts
+function slugify(text2) {
+  return text2.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function buildItems(pages) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    for (const field of page.fields) {
+      const base = `${page.pageId}:${slugify(String(field.campo ?? ""))}`;
+      const count = (seen.get(base) ?? 0) + 1;
+      seen.set(base, count);
+      const id = count > 1 ? `${base}-${count}` : base;
+      items.push({
+        ...field,
+        id,
+        page: { pageId: page.pageId, title: page.title, url: page.url }
+      });
+    }
+  }
+  return items;
+}
+var pcmDomain = {
+  id: "pcm-additional-info",
+  title: "PCM \u2014 Regras de obrigatoriedade do additionalInfo",
+  description: "Regras de preenchimento do campo additionalInfo das p\xE1ginas PCM (Plataforma de Coleta de M\xE9tricas) do Confluence do Open Finance Brasil (Inicia\xE7\xE3o de Pagamentos, Pagamentos Autom\xE1ticos, Sem Redirecionamento, DC-*). Cada item \xE9 um campo com regra, m\xE9todos, endpoints, vers\xF5es, tamanho m\xE1ximo e exemplo.",
+  ttlHours: 24,
+  filters: [
+    { name: "field", description: "Match exato no nome do campo (case-insensitive)" },
+    { name: "contains", description: "Substring em campo ou definicao" },
+    { name: "endpoint", description: "Substring em endpoints[] (ex.: /pix)" },
+    { name: "method", description: "Verbo HTTP presente em metodos[] (ex.: POST)" },
+    { name: "page", description: "Substring no t\xEDtulo da p\xE1gina Confluence" }
+  ],
+  async extract(ctx) {
+    const total = pcmConfig.pages.length;
+    const pages = [];
+    for (const [i, page] of pcmConfig.pages.entries()) {
+      if (ctx?.signal?.aborted) throw new Error("Extra\xE7\xE3o cancelada pelo cliente");
+      if (i > 0) await sleep(pcmConfig.interRequestDelayMs);
+      ctx?.onProgress?.(i, total, `Extraindo "${page.title}"`);
+      const { html, url } = await fetchConfluencePage(
+        pcmConfig.confluenceBaseUrl,
+        page.pageId,
+        pcmConfig.retryDelaysMs,
+        ctx?.signal
+      );
+      pages.push({ pageId: page.pageId, title: page.title, url, fields: parseAdditionalInfoTables(html) });
+    }
+    ctx?.onProgress?.(total, total);
+    return { items: buildItems(pages) };
+  },
+  search(data, query, filters = {}) {
+    const field = filters.field?.trim().toLowerCase();
+    const contains = filters.contains ? normalize(filters.contains) : void 0;
+    const endpoint = filters.endpoint?.toLowerCase();
+    const method = filters.method?.toUpperCase();
+    const page = filters.page ? normalize(filters.page) : void 0;
+    return data.items.filter((item) => {
+      const campo = String(item.campo ?? "");
+      if (page && !normalize(item.page.title).includes(page)) return false;
+      if (field && campo.trim().toLowerCase() !== field) return false;
+      if (contains && !normalize(`${campo} ${item.definicao ?? ""}`).includes(contains)) return false;
+      if (endpoint && !item.endpoints.some((e) => e.toLowerCase().includes(endpoint))) return false;
+      if (method && !item.metodos.some((m) => m.toUpperCase() === method)) return false;
+      if (query?.trim()) {
+        const haystack = `${campo} ${item.definicao ?? ""} ${item.regraDePreenchimento ?? ""}`;
+        if (!matchesQuery(haystack, query)) return false;
+      }
+      return true;
+    });
+  },
+  getItem(data, id) {
+    return data.items.find((i) => i.id === id) ?? null;
+  }
+};
+
+// src/domains/_openapi/parser.ts
+import { parse } from "yaml";
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+function parseOpenApiSpec(yamlText, specName) {
+  const spec = parse(yamlText);
+  const items = [];
+  for (const [path, pathItem] of Object.entries(spec.paths ?? {})) {
+    for (const method of HTTP_METHODS) {
+      const op = pathItem[method];
+      if (!op) continue;
+      items.push({
+        id: `${specName}:${method.toUpperCase()} ${path}`,
+        type: "operation",
+        path,
+        method: method.toUpperCase(),
+        summary: op.summary ?? null,
+        description: op.description ?? null,
+        tags: op.tags ?? [],
+        detail: op
+      });
+    }
+  }
+  for (const [name, schema] of Object.entries(spec.components?.schemas ?? {})) {
+    items.push({
+      id: `${specName}:schema:${name}`,
+      type: "schema",
+      name,
+      description: schema.description ?? null,
+      required: schema.required ?? [],
+      detail: schema
+    });
+  }
+  return items;
+}
+
+// src/domains/_openapi/domain.ts
+function summarize(item) {
+  const { detail: _detail, ...rest } = item;
+  return rest;
+}
+function createOpenApiDomain(config) {
+  return {
+    id: config.id,
+    title: config.title,
+    description: config.description,
+    ttlHours: 24,
+    filters: [
+      { name: "path", description: `Substring no path do endpoint (ex.: ${config.pathExample})` },
+      { name: "method", description: "Verbo HTTP exato (ex.: POST)" },
+      { name: "schema", description: "Substring no nome do schema (case-insensitive)" }
+    ],
+    async extract(ctx) {
+      if (ctx?.signal?.aborted) throw new Error("Extra\xE7\xE3o cancelada pelo cliente");
+      ctx?.onProgress?.(0, 1, `Baixando spec ${config.specName} ${config.specVersion}`);
+      const response = await fetchWithRetry(config.url, {
+        retryDelaysMs: config.retryDelaysMs,
+        signal: ctx?.signal
+      });
+      const yamlText = await response.text();
+      ctx?.onProgress?.(1, 1);
+      return { items: parseOpenApiSpec(yamlText, config.specName) };
+    },
+    search(data, query, filters = {}) {
+      const path = filters.path ? normalize(filters.path) : void 0;
+      const method = filters.method?.toUpperCase();
+      const schema = filters.schema ? normalize(filters.schema) : void 0;
+      return data.items.filter((item) => {
+        if (path && !normalize(String(item.path ?? "")).includes(path)) return false;
+        if (method && item.method !== method) return false;
+        if (schema && !normalize(String(item.name ?? "")).includes(schema)) return false;
+        if (query?.trim()) {
+          const haystack = [item.path, item.summary, item.description, item.name].map((v) => String(v ?? "")).join(" ");
+          if (!matchesQuery(haystack, query)) return false;
+        }
+        return true;
+      }).map(summarize);
+    },
+    getItem(data, id) {
+      return data.items.find((i) => i.id === id) ?? null;
+    }
+  };
+}
+
+// src/domains/payments-v4-openapi/config.ts
+var paymentsConfig = {
+  id: "payments-v4-openapi",
+  title: "API de Pagamentos \u2014 spec OpenAPI 4.0.0",
+  description: "Spec OpenAPI oficial da API de Pagamentos (Pix) do Open Finance Brasil. Itens type=operation (endpoints, um por m\xE9todo+path) e type=schema (payloads). search devolve resumos; use get_item para o n\xF3 completo da spec.",
+  pathExample: "/pix/payments",
+  specName: "payments",
+  specVersion: "4.0.0",
+  url: "https://raw.githubusercontent.com/OpenBanking-Brasil/openapi/main/swagger-apis/payments/4.0.0.yml",
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3]
+};
+
+// src/domains/payments-v4-openapi/index.ts
+var paymentsDomain = createOpenApiDomain(paymentsConfig);
+
+// src/domains/payments-v5-openapi/config.ts
+var paymentsV5Config = {
+  id: "payments-v5-openapi",
+  title: "API de Pagamentos \u2014 spec OpenAPI 5.0.0",
+  description: "Spec OpenAPI oficial da API de Inicia\xE7\xE3o de Pagamentos (Pix) do Open Finance Brasil, vers\xE3o 5. Inclui endpoints de consentimento (/consents) e de pagamento (/pix/payments). Itens type=operation (endpoints, um por m\xE9todo+path) e type=schema (payloads). search devolve resumos; use get_item para o n\xF3 completo da spec.",
+  pathExample: "/pix/payments",
+  specName: "payments",
+  specVersion: "5.0.0",
+  url: "https://raw.githubusercontent.com/OpenBanking-Brasil/all-services-repo/refs/heads/main/api_payment_initiation_-_open_finance_brasil/5.0.0.yaml",
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3]
+};
+
+// src/domains/payments-v5-openapi/index.ts
+var paymentsV5Domain = createOpenApiDomain(paymentsV5Config);
+
+// src/domains/enrollments-v2-openapi/config.ts
+var enrollmentsV2Config = {
+  id: "enrollments-v2-openapi",
+  title: "API de V\xEDnculo de Dispositivo (Enrollments) \u2014 spec OpenAPI 2.2.0",
+  description: "Spec OpenAPI oficial da API de Enrollments (V\xEDnculo de Dispositivo) do Open Finance Brasil, vers\xE3o 2. Cobre o pagamento sem redirecionamento: v\xEDnculo de dispositivos (FIDO), autoriza\xE7\xE3o de consentimentos e Pix Autom\xE1tico. Endpoints /enrollments, /consents/{consentId}/authorise e /recurring-consents/{recurringConsentId}/authorise. Itens type=operation (endpoints, um por m\xE9todo+path) e type=schema (payloads). search devolve resumos; use get_item para o n\xF3 completo da spec.",
+  pathExample: "/enrollments",
+  specName: "enrollments",
+  specVersion: "2.2.0",
+  url: "https://raw.githubusercontent.com/OpenBanking-Brasil/all-services-repo/refs/heads/main/api_enrollments_for_payment_initiation_-_open_finance_brasil/2.2.0.yaml",
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3]
+};
+
+// src/domains/enrollments-v2-openapi/index.ts
+var enrollmentsV2Domain = createOpenApiDomain(enrollmentsV2Config);
+
+// src/domains/automatic-payments-v2-openapi/config.ts
+var automaticPaymentsV2Config = {
+  id: "automatic-payments-v2-openapi",
+  title: "API de Pagamentos Autom\xE1ticos (Automatic Payments) \u2014 spec OpenAPI 2.2.0",
+  description: "Spec OpenAPI oficial da API de Automatic Payments do Open Finance Brasil, vers\xE3o 2. Cobre a inicia\xE7\xE3o de pagamentos autom\xE1ticos (Pix Autom\xE1tico e Transfer\xEAncias Inteligentes) mediante consentimento recorrente. Endpoints /recurring-consents (cria\xE7\xE3o, consulta e edi\xE7\xE3o/revoga\xE7\xE3o) e /pix/recurring-payments (cria\xE7\xE3o, retry, consulta e cancelamento); scope recurring-payments. Itens type=operation (endpoints, um por m\xE9todo+path) e type=schema (payloads). search devolve resumos; use get_item para o n\xF3 completo da spec.",
+  pathExample: "/pix/recurring-payments",
+  specName: "automatic-payments",
+  specVersion: "2.2.0",
+  url: "https://raw.githubusercontent.com/OpenBanking-Brasil/all-services-repo/refs/heads/main/api_automatic_payments_-_open_finance_brasil/2.2.0.yaml",
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3]
+};
+
+// src/domains/automatic-payments-v2-openapi/index.ts
+var automaticPaymentsV2Domain = createOpenApiDomain(automaticPaymentsV2Config);
+
+// src/domains/consents-v3-openapi/config.ts
+var consentsV3Config = {
+  id: "consents-v3-openapi",
+  title: "API de Consentimentos \u2014 spec OpenAPI 3.3.1",
+  description: "Spec OpenAPI oficial da API de Consentimentos (Dados Cadastrais e Transacionais) do Open Finance Brasil, vers\xE3o 3.3.1. Cobre cria\xE7\xE3o (POST /consents), consulta (GET /consents/{consentId}), revoga\xE7\xE3o (DELETE /consents/{consentId}), renova\xE7\xE3o (POST /consents/{consentId}/extends) e hist\xF3rico de renova\xE7\xF5es (GET /consents/{consentId}/extensions). Itens type=operation (um por m\xE9todo+path) e type=schema (payloads, ex.: CreateConsent, ResponseConsent, LoggedUser, BusinessEntity). search devolve resumos; use get_item para o n\xF3 completo da spec.",
+  pathExample: "/consents/{consentId}",
+  specName: "consents",
+  specVersion: "3.3.1",
+  url: "https://openbanking-brasil.github.io/openapi/swagger-apis/consents/3.3.1.yml",
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3]
+};
+
+// src/domains/consents-v3-openapi/index.ts
+var consentsV3Domain = createOpenApiDomain(consentsV3Config);
+
+// src/domains/pcm-openapi/config.ts
+var pcmOpenapiConfig = {
+  specName: "pcm",
+  specVersion: "1.0.0",
+  url: "https://raw.githubusercontent.com/OpenBanking-Brasil/pcm-specs/refs/heads/feature/correct-paths/PCM-current.openapi.yaml",
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3]
+};
+
+// src/domains/pcm-openapi/parser.ts
+import { parse as parse2 } from "yaml";
+var HTTP_METHODS2 = ["get", "post", "put", "patch", "delete"];
+function parseOpenApiSpec2(yamlText, specName) {
+  const spec = parse2(yamlText);
+  const items = [];
+  for (const [path, pathItem] of Object.entries(spec.paths ?? {})) {
+    for (const method of HTTP_METHODS2) {
+      const op = pathItem[method];
+      if (!op) continue;
+      items.push({
+        id: `${specName}:${method.toUpperCase()} ${path}`,
+        type: "operation",
+        path,
+        method: method.toUpperCase(),
+        summary: op.summary ?? null,
+        description: op.description ?? null,
+        tags: op.tags ?? [],
+        detail: op
+      });
+    }
+  }
+  for (const [name, schema] of Object.entries(spec.components?.schemas ?? {})) {
+    items.push({
+      id: `${specName}:schema:${name}`,
+      type: "schema",
+      name,
+      description: schema.description ?? null,
+      required: schema.required ?? [],
+      detail: schema
+    });
+  }
+  return items;
+}
+
+// src/domains/pcm-openapi/index.ts
+function summarize2(item) {
+  const { detail: _detail, ...rest } = item;
+  return rest;
+}
+var pcmOpenapiDomain = {
+  id: "pcm-openapi",
+  title: `PCM \u2014 spec OpenAPI ${pcmOpenapiConfig.specVersion}`,
+  description: "Spec OpenAPI oficial da PCM (Plataforma de Coleta de M\xE9tricas) do Open Finance Brasil. Cobre os endpoints de reporte (report-api v1/v2), hybrid-flow, opendata, consents/stock, credit-portabilities, payments/status e token. Itens type=operation (um por m\xE9todo+path) e type=schema (payloads). search devolve resumos; use get_item para o n\xF3 completo da spec.",
+  ttlHours: 24,
+  filters: [
+    { name: "path", description: "Substring no path do endpoint (ex.: /report-api/v1/private/report)" },
+    { name: "method", description: "Verbo HTTP exato (ex.: POST)" },
+    { name: "schema", description: "Substring no nome do schema (case-insensitive)" }
+  ],
+  async extract(ctx) {
+    if (ctx?.signal?.aborted) throw new Error("Extra\xE7\xE3o cancelada pelo cliente");
+    ctx?.onProgress?.(0, 1, `Baixando spec ${pcmOpenapiConfig.specName} ${pcmOpenapiConfig.specVersion}`);
+    const response = await fetchWithRetry(pcmOpenapiConfig.url, {
+      retryDelaysMs: pcmOpenapiConfig.retryDelaysMs,
+      signal: ctx?.signal
+    });
+    const yamlText = await response.text();
+    ctx?.onProgress?.(1, 1);
+    return { items: parseOpenApiSpec2(yamlText, pcmOpenapiConfig.specName) };
+  },
+  search(data, query, filters = {}) {
+    const path = filters.path ? normalize(filters.path) : void 0;
+    const method = filters.method?.toUpperCase();
+    const schema = filters.schema ? normalize(filters.schema) : void 0;
+    return data.items.filter((item) => {
+      if (path && !normalize(String(item.path ?? "")).includes(path)) return false;
+      if (method && item.method !== method) return false;
+      if (schema && !normalize(String(item.name ?? "")).includes(schema)) return false;
+      if (query?.trim()) {
+        const haystack = [item.path, item.summary, item.description, item.name].map((v) => String(v ?? "")).join(" ");
+        if (!matchesQuery(haystack, query)) return false;
+      }
+      return true;
+    }).map(summarize2);
+  },
+  getItem(data, id) {
+    return data.items.find((i) => i.id === id) ?? null;
+  }
+};
+
+// src/domains/_confluence-sections/parser.ts
+import * as cheerio2 from "cheerio";
+var HEADING_SELECTOR = "h1, h2, h3";
+function cellText2($, el) {
+  const clone = $(el).clone();
+  clone.find("br").replaceWith("\n");
+  return clone.text().replace(/ /g, " ").replace(/[ \t]+/g, " ").trim();
+}
+function blockText($, node) {
+  const $node = $(node);
+  if (node.tagName === "table") {
+    return $node.find("tr").toArray().map(
+      (tr) => $(tr).find("th, td").toArray().map((c) => cellText2($, c)).join(" | ")
+    ).filter((line) => line.replace(/[ |]/g, "").length > 0).join("\n");
+  }
+  return cellText2($, node);
+}
+function parseSections(html) {
+  const $ = cheerio2.load(html);
+  const sections = [];
+  const headings = $(HEADING_SELECTOR).toArray();
+  const first = headings[0];
+  const introNodes = first ? $(first).prevAll().toArray().reverse() : $("body").contents().toArray();
+  const introParts = introNodes.map((n) => blockText($, n)).filter(Boolean);
+  const introContent = introParts.join("\n\n").trim();
+  if (introContent) sections.push({ heading: "intro", level: 0, content: introContent });
+  for (const el of headings) {
+    const heading = cellText2($, el);
+    if (!heading) continue;
+    const level = Number(el.tagName.slice(1));
+    const parts = $(el).nextUntil(HEADING_SELECTOR).toArray().map((n) => blockText($, n)).filter(Boolean);
+    sections.push({ heading, level, content: parts.join("\n\n").trim() });
+  }
+  return sections;
+}
+
+// src/domains/_confluence-sections/domain.ts
+var SNIPPET_LEN = 200;
+function slugify2(text2) {
+  return text2.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function buildItems2(pages) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    for (const section of page.sections) {
+      const base = `${page.pageId}:${slugify2(section.heading)}`;
+      const count = (seen.get(base) ?? 0) + 1;
+      seen.set(base, count);
+      const id = count > 1 ? `${base}-${count}` : base;
+      items.push({
+        id,
+        heading: section.heading,
+        level: section.level,
+        content: section.content,
+        page: { pageId: page.pageId, title: page.title, url: page.url }
+      });
+    }
+  }
+  return items;
+}
+function summarize3(item) {
+  const { content, ...rest } = item;
+  const snippet = content.length > SNIPPET_LEN ? `${content.slice(0, SNIPPET_LEN)}\u2026` : content;
+  return { ...rest, snippet };
+}
+function createConfluenceSectionsDomain(config) {
+  return {
+    id: config.id,
+    title: config.title,
+    description: config.description,
+    ttlHours: 24,
+    filters: [
+      { name: "page", description: "Substring no t\xEDtulo da p\xE1gina Confluence" },
+      { name: "heading", description: "Substring no t\xEDtulo da se\xE7\xE3o (heading)" },
+      { name: "contains", description: "Substring no conte\xFAdo da se\xE7\xE3o" }
+    ],
+    async extract(ctx) {
+      const total = config.pages.length;
+      const pages = [];
+      for (const [i, page] of config.pages.entries()) {
+        if (ctx?.signal?.aborted) throw new Error("Extra\xE7\xE3o cancelada pelo cliente");
+        if (i > 0) await sleep(config.interRequestDelayMs);
+        ctx?.onProgress?.(i, total, `Extraindo "${page.title}"`);
+        const { html, url } = await fetchConfluencePage(
+          config.confluenceBaseUrl,
+          page.pageId,
+          config.retryDelaysMs,
+          ctx?.signal
+        );
+        pages.push({ pageId: page.pageId, title: page.title, url, sections: parseSections(html) });
+      }
+      ctx?.onProgress?.(total, total);
+      return { items: buildItems2(pages) };
+    },
+    search(data, query, filters = {}) {
+      const page = filters.page ? normalize(filters.page) : void 0;
+      const heading = filters.heading ? normalize(filters.heading) : void 0;
+      const contains = filters.contains ? normalize(filters.contains) : void 0;
+      return data.items.filter((item) => {
+        if (page && !normalize(item.page.title).includes(page)) return false;
+        if (heading && !normalize(item.heading).includes(heading)) return false;
+        if (contains && !normalize(item.content).includes(contains)) return false;
+        if (query?.trim()) {
+          if (!matchesQuery(`${item.heading} ${item.content}`, query)) return false;
+        }
+        return true;
+      }).map(summarize3);
+    },
+    getItem(data, id) {
+      return data.items.find((i) => i.id === id) ?? null;
+    }
+  };
+}
+
+// src/domains/pcm-business-rules/config.ts
+var pcmBusinessRulesConfig = {
+  id: "pcm-business-rules",
+  title: "PCM \u2014 Regras de neg\xF3cio (Reporte, Processamento, Diverg\xEAncias)",
+  description: "Regras de neg\xF3cio da PCM (Plataforma de Coleta de M\xE9tricas) do Open Finance Brasil, extra\xEDdas das p\xE1ginas Confluence: Especifica\xE7\xE3o T\xE9cnica, Reporte, Processamento, Diverg\xEAncias e Manual de Integra\xE7\xE3o. Cada item \xE9 uma se\xE7\xE3o (heading) da p\xE1gina. search devolve um snippet do conte\xFAdo; use get_item para o texto completo da se\xE7\xE3o.",
+  confluenceBaseUrl: "https://openfinancebrasil.atlassian.net",
+  interRequestDelayMs: 2e3,
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3],
+  pages: [
+    { pageId: "37945356", title: "Especifica\xE7\xE3o T\xE9cnica" },
+    { pageId: "37945368", title: "Reporte, Processamento e Diverg\xEAncias" },
+    { pageId: "37879861", title: "Reporte" },
+    { pageId: "37912631", title: "Processamento" },
+    { pageId: "37945515", title: "Manual de Integra\xE7\xE3o" }
+  ]
+};
+
+// src/domains/pcm-business-rules/index.ts
+var pcmBusinessRulesDomain = createConfluenceSectionsDomain(pcmBusinessRulesConfig);
+
+// src/domains/jornada-otimizada/config.ts
+var jornadaOtimizadaConfig = {
+  id: "jornada-otimizada",
+  title: "Jornada Otimizada",
+  description: "Conhecimento regulat\xF3rio da Jornada Otimizada do Open Finance Brasil, extra\xEDdo das p\xE1ginas Confluence: Jornada Otimizada (introdu\xE7\xE3o), Orienta\xE7\xF5es Gerais, Transfer\xEAncias Inteligentes e Jornada sem Redirecionamento. Cada item \xE9 uma se\xE7\xE3o (heading) da p\xE1gina. search devolve um snippet do conte\xFAdo; use get_item para o texto completo da se\xE7\xE3o.",
+  confluenceBaseUrl: "https://openfinancebrasil.atlassian.net",
+  interRequestDelayMs: 2e3,
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3],
+  pages: [
+    { pageId: "1128890377", title: "Jornada Otimizada" },
+    { pageId: "1129250817", title: "Orienta\xE7\xF5es Gerais" },
+    { pageId: "1129021472", title: "Transfer\xEAncias Inteligentes" },
+    { pageId: "1128857617", title: "Jornada sem Redirecionamento" }
+  ]
+};
+
+// src/domains/jornada-otimizada/index.ts
+var jornadaOtimizadaDomain = createConfluenceSectionsDomain(jornadaOtimizadaConfig);
+
+// src/domains/mqd/config.ts
+var mqdConfig = {
+  id: "mqd",
+  title: "Motor de Qualidade de Dados (MQD)",
+  description: "Conhecimento regulat\xF3rio do Motor de Qualidade de Dados (MQD) do Open Finance Brasil, extra\xEDdo das p\xE1ginas Confluence: Especifica\xE7\xE3o T\xE9cnica, Arquitetura, Documenta\xE7\xE3o da API, Manual de Instala\xE7\xE3o, Tabela de Endpoints Validados, FAQ e Troubleshooting. Cada item \xE9 uma se\xE7\xE3o (heading) de uma p\xE1gina. search devolve um snippet do conte\xFAdo; use get_item para o texto completo da se\xE7\xE3o. A spec OpenAPI do MQD est\xE1 inclu\xEDda como conte\xFAdo da se\xE7\xE3o da p\xE1gina Documenta\xE7\xE3o da API.",
+  confluenceBaseUrl: "https://openfinancebrasil.atlassian.net",
+  interRequestDelayMs: 2e3,
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3],
+  pages: [
+    { pageId: "362578617", title: "Especifica\xE7\xE3o T\xE9cnica" },
+    { pageId: "362578657", title: "Arquitetura" },
+    { pageId: "362578918", title: "Documenta\xE7\xE3o da API" },
+    { pageId: "362578967", title: "Manual de Instala\xE7\xE3o" },
+    { pageId: "619413971", title: "Tabela de Endpoints Validados" },
+    { pageId: "362579143", title: "FAQ" },
+    { pageId: "362579195", title: "Troubleshooting" }
+  ]
+};
+
+// src/domains/mqd/index.ts
+var mqdDomain = createConfluenceSectionsDomain(mqdConfig);
+
+// src/domains/webhook-v1-openapi/config.ts
+var webhookConfig = {
+  id: "webhook-v1-openapi",
+  title: "API de Webhook \u2014 spec OpenAPI 1.3.0",
+  description: "Spec OpenAPI oficial da API de Webhook do Open Finance Brasil, que notifica mudan\xE7as de estado das demais APIs. 5 opera\xE7\xF5es POST (type=operation): consentNotification e pixPaymentNotification (Pagamentos), enrollmentIdNotification (Enrollments), recurringConsentIdNotification e recurringPaymentIdNotification (Pagamentos Autom\xE1ticos); e schemas type=schema (RequestBodyWebhook, RequestBodyWebhookEvents, EventType, Timestamp, xWebhookInteractionId). search devolve resumos; use get_item para o n\xF3 completo da spec.",
+  pathExample: "/payments/{versionApi}/consents/{consentId}",
+  specName: "webhook",
+  specVersion: "1.3.0",
+  url: "https://raw.githubusercontent.com/OpenBanking-Brasil/all-services-repo/refs/heads/main/api_webhook_-_open_finance_brasil/1.3.0.yaml",
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3]
+};
+
+// src/domains/webhook-v1-openapi/index.ts
+var webhookDomain = createOpenApiDomain(webhookConfig);
+
+// src/domains/seguranca/config.ts
+var segurancaConfig = {
+  id: "seguranca",
+  title: "Seguran\xE7a",
+  description: "Conhecimento regulat\xF3rio de Seguran\xE7a do Open Finance Brasil, extra\xEDdo das p\xE1ginas Confluence sob a \xE1rvore Seguran\xE7a: Vis\xE3o Geral, Introdu\xE7\xE3o, Guia do Usu\xE1rio, Perfil de Seguran\xE7a (DCR, FAPI, CIBA, criptografia de ID_TOKEN), Padr\xE3o de Certificados e diretrizes de valida\xE7\xE3o, Assinaturas, Casos de Erro, Redirecionamento App-to-App, Gloss\xE1rio e Pol\xEDtica de Versionamento. Cada item \xE9 uma se\xE7\xE3o (heading) de uma p\xE1gina. search devolve um snippet do conte\xFAdo; use get_item para o texto completo da se\xE7\xE3o.",
+  confluenceBaseUrl: "https://openfinancebrasil.atlassian.net",
+  interRequestDelayMs: 2e3,
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3],
+  pages: [
+    { pageId: "240648227", title: "Vis\xE3o Geral" },
+    { pageId: "240648385", title: "Introdu\xE7\xE3o" },
+    { pageId: "240648471", title: "Guia do Usu\xE1rio" },
+    { pageId: "240648789", title: "Perfil de Seguran\xE7a" },
+    { pageId: "240649257", title: "DCR - Dynamic Client Registration" },
+    { pageId: "1799421990", title: "FAPI - Financial-grade API Security Profile" },
+    { pageId: "1799946241", title: "CIBA - Client Initiated Backchannel Authentication" },
+    { pageId: "240649215", title: "Requisitos de criptografia ID_TOKEN" },
+    { pageId: "240649813", title: "Padr\xE3o de Certificados" },
+    { pageId: "1799946375", title: "Diretrizes para valida\xE7\xE3o de certificados digitais" },
+    { pageId: "240650189", title: "Assinaturas" },
+    { pageId: "240650255", title: "Casos de Erro" },
+    { pageId: "240650317", title: "Redirecionamento App-to-App" },
+    { pageId: "240650381", title: "Gloss\xE1rio de Seguran\xE7a" },
+    { pageId: "240650571", title: "Versionamento - Tipos" },
+    { pageId: "240650601", title: "Versionamento - Ciclo de Vida" },
+    { pageId: "240650643", title: "Versionamento - Fluxo de especifica\xE7\xE3o" },
+    { pageId: "240650712", title: "Versionamento - Change log" }
+  ]
+};
+
+// src/domains/seguranca/index.ts
+var segurancaDomain = createConfluenceSectionsDomain(segurancaConfig);
+
+// src/domains/participantes/config.ts
+var participantesConfig = {
+  id: "participantes",
+  title: "Diret\xF3rio de Participantes",
+  description: "Diret\xF3rio p\xFAblico de participantes do Open Finance Brasil: organiza\xE7\xF5es, marcas (authorisation servers) e fam\xEDlias de API suportadas com vers\xF5es. Um item por organiza\xE7\xE3o. search devolve resumo (nome, CNPJ, status, fam\xEDlias de API); use get_item para o n\xF3 completo com AuthorisationServers, endpoints e certifica\xE7\xF5es.",
+  url: "https://data.directory.openbankingbrasil.org.br/participants",
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3]
+};
+
+// src/domains/participantes/parser.ts
+function parseParticipants(jsonText) {
+  const orgs = JSON.parse(jsonText);
+  return orgs.map((org) => {
+    const servers = org.AuthorisationServers ?? [];
+    const families = /* @__PURE__ */ new Set();
+    for (const server2 of servers) {
+      for (const resource of server2.ApiResources ?? []) {
+        if (!resource.ApiFamilyType) continue;
+        families.add(
+          resource.ApiVersion ? `${resource.ApiFamilyType} ${resource.ApiVersion}` : resource.ApiFamilyType
+        );
+      }
+    }
+    return {
+      id: org.OrganisationId,
+      name: org.OrganisationName ?? "",
+      cnpj: org.RegistrationNumber ?? null,
+      status: org.Status ?? null,
+      servers: servers.length,
+      serverNames: servers.map((s) => s.CustomerFriendlyName ?? "").filter(Boolean),
+      apiFamilies: [...families].sort(),
+      detail: org
+    };
+  });
+}
+
+// src/domains/participantes/index.ts
+function summarize4(item) {
+  const { detail: _detail, ...rest } = item;
+  return rest;
+}
+var participantesDomain = {
+  id: participantesConfig.id,
+  title: participantesConfig.title,
+  description: participantesConfig.description,
+  ttlHours: 24,
+  filters: [
+    { name: "name", description: "Substring no nome da organiza\xE7\xE3o ou na marca (CustomerFriendlyName)" },
+    { name: "api", description: "Substring na fam\xEDlia de API (ex.: payments, automatic-payments)" },
+    { name: "status", description: "Status exato da organiza\xE7\xE3o (ex.: Active)" },
+    { name: "cnpj", description: "Substring no CNPJ (RegistrationNumber, s\xF3 d\xEDgitos)" }
+  ],
+  async extract(ctx) {
+    if (ctx?.signal?.aborted) throw new Error("Extra\xE7\xE3o cancelada pelo cliente");
+    ctx?.onProgress?.(0, 1, "Baixando diret\xF3rio de participantes");
+    const response = await fetchWithRetry(participantesConfig.url, {
+      retryDelaysMs: participantesConfig.retryDelaysMs,
+      signal: ctx?.signal
+    });
+    const jsonText = await response.text();
+    ctx?.onProgress?.(1, 1);
+    return { items: parseParticipants(jsonText) };
+  },
+  search(data, query, filters = {}) {
+    const name = filters.name ? normalize(filters.name) : void 0;
+    const api = filters.api ? normalize(filters.api) : void 0;
+    const status = filters.status ? normalize(filters.status) : void 0;
+    const cnpj = filters.cnpj?.replace(/\D/g, "");
+    return data.items.filter((item) => {
+      if (name && !normalize([item.name, ...item.serverNames].join(" ")).includes(name)) return false;
+      if (api && !item.apiFamilies.some((f) => normalize(f).includes(api))) return false;
+      if (status && normalize(item.status ?? "") !== status) return false;
+      if (cnpj && !(item.cnpj ?? "").includes(cnpj)) return false;
+      if (query?.trim()) {
+        const haystack = [item.name, ...item.serverNames, ...item.apiFamilies, item.cnpj ?? ""].join(" ");
+        if (!matchesQuery(haystack, query)) return false;
+      }
+      return true;
+    }).map(summarize4);
+  },
+  getItem(data, id) {
+    return data.items.find((i) => i.id === id) ?? null;
+  }
+};
+
+// src/domains/portal/config.ts
+var portalConfig = {
+  id: "portal",
+  title: "Portal do Desenvolvedor (busca ao vivo)",
+  description: "Busca ao vivo em todo o Portal do Desenvolvedor do Open Finance Brasil (Confluence, espa\xE7o OF). Use quando os dom\xEDnios espec\xEDficos n\xE3o cobrirem o assunto. search exige query e consulta a fonte a cada chamada (sempre atualizado, sem cache); get_item baixa a p\xE1gina inteira estruturada em se\xE7\xF5es. Retorna no m\xE1ximo os 25 resultados mais relevantes; matches nunca excede 25.",
+  confluenceBaseUrl: "https://openfinancebrasil.atlassian.net",
+  space: "OF",
+  searchLimit: 25,
+  retryDelaysMs: [2e3, 4e3, 8e3, 16e3]
+};
+
+// src/domains/portal/parser.ts
+function buildCql(query, space) {
+  const escaped = query.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `siteSearch ~ "${escaped}" AND type = page AND space = "${space}"`;
+}
+function parseSearchResults(json, baseUrl) {
+  const results = json.results ?? [];
+  return results.filter((r) => r.content?.id).map((r) => ({
+    id: String(r.content.id),
+    title: r.content?.title ?? r.title ?? "",
+    excerpt: (r.excerpt ?? "").replace(/@@@(end)?hl@@@/g, ""),
+    url: r.url ? `${baseUrl}/wiki${r.url}` : null,
+    lastModified: r.lastModified ?? null
+  }));
+}
+
+// src/domains/portal/index.ts
+var portalDomain = {
+  id: portalConfig.id,
+  title: portalConfig.title,
+  description: portalConfig.description,
+  filters: [],
+  live: {
+    async search(query, _filters, ctx) {
+      const cql = buildCql(query, portalConfig.space);
+      const url = `${portalConfig.confluenceBaseUrl}/wiki/rest/api/search?cql=${encodeURIComponent(cql)}&limit=${portalConfig.searchLimit}`;
+      const response = await fetchWithRetry(url, {
+        retryDelaysMs: portalConfig.retryDelaysMs,
+        signal: ctx?.signal
+      });
+      return parseSearchResults(await response.json(), portalConfig.confluenceBaseUrl);
+    },
+    async getItem(id, ctx) {
+      if (!/^\d+$/.test(id)) return null;
+      try {
+        const { html, title, url } = await fetchConfluencePage(
+          portalConfig.confluenceBaseUrl,
+          id,
+          portalConfig.retryDelaysMs,
+          ctx?.signal
+        );
+        return { id, title: title ?? null, url, sections: parseSections(html) };
+      } catch (err) {
+        if (err.message.includes("HTTP 404")) return null;
+        throw err;
+      }
+    }
+  }
+};
+
+// src/core/registry.ts
+var domains = [
+  pcmDomain,
+  paymentsDomain,
+  paymentsV5Domain,
+  enrollmentsV2Domain,
+  automaticPaymentsV2Domain,
+  consentsV3Domain,
+  pcmOpenapiDomain,
+  pcmBusinessRulesDomain,
+  jornadaOtimizadaDomain,
+  mqdDomain,
+  webhookDomain,
+  segurancaDomain,
+  participantesDomain,
+  portalDomain
+];
+
+// src/core/server.ts
+function compact(item) {
+  const out = {};
+  for (const [k, v] of Object.entries(item)) {
+    if (v === null) continue;
+    if (Array.isArray(v) && v.length === 0) continue;
+    out[k] = v;
+  }
+  return out;
+}
+function text(obj) {
+  return { content: [{ type: "text", text: JSON.stringify(obj, null, 1) }] };
+}
+function errorText(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function findDomain(id) {
+  return domains.find((d) => d.id === id);
+}
+var validIds = () => domains.map((d) => d.id).join(", ");
+var domainIdSchema = z.enum(domains.map((d) => d.id)).describe("Id do dom\xEDnio (ver list_domains)");
+function extractContext(extra) {
+  const progressToken = extra._meta?.progressToken;
+  return {
+    signal: extra.signal,
+    onProgress: progressToken === void 0 ? void 0 : (progress, total, message) => {
+      extra.sendNotification({
+        method: "notifications/progress",
+        params: { progressToken, progress, total, message }
+      }).catch(() => {
+      });
+    }
+  };
+}
+function createServer() {
+  const server2 = new McpServer(
+    { name: "opf-br-mcp", version: PACKAGE_VERSION },
+    {
+      instructions: "Conhecimento regulat\xF3rio do Open Finance Brasil. Fluxo: list_domains para descobrir dom\xEDnios e filtros \u2192 search(domain, ...) para buscar \u2192 get_item(domain, id) para o registro completo. Os ids n\xE3o s\xE3o adivinh\xE1veis \u2014 sempre venha de search. A primeira consulta a um dom\xEDnio extrai das fontes p\xFAblicas e pode levar ~30s; as seguintes usam cache."
+    }
+  );
+  server2.registerTool(
+    "list_domains",
+    {
+      title: "Listar dom\xEDnios",
+      description: "Lista os dom\xEDnios de conhecimento do Open Finance Brasil dispon\xEDveis neste server, com os filtros aceitos por cada um e o estado do cache local. Comece por aqui; depois use search(domain, ...) e get_item(domain, id).",
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async () => {
+      const out = domains.map((d) => {
+        if (d.live) {
+          return { id: d.id, title: d.title, description: d.description, filters: d.filters, live: true };
+        }
+        const cached = readCache(d.id);
+        return {
+          id: d.id,
+          title: d.title,
+          description: d.description,
+          filters: d.filters,
+          cachedItems: cached?.data.items.length ?? 0,
+          extractedAt: cached?.extractedAt ?? null
+        };
+      });
+      return text(out);
+    }
+  );
+  server2.registerTool(
+    "search",
+    {
+      title: "Buscar em um dom\xEDnio",
+      description: "Busca filtrada em um dom\xEDnio. `filters` aceita as chaves listadas em list_domains para o dom\xEDnio (combinadas em AND); `query` busca substring nos campos textuais. Retorno compacto (omite nulls). Cada resultado tem `id` para usar em get_item. Na primeira consulta o dom\xEDnio \xE9 extra\xEDdo das fontes p\xFAblicas (pode levar ~30s).",
+      inputSchema: {
+        domain: domainIdSchema,
+        query: z.string().optional().describe("Substring em campos textuais"),
+        filters: z.record(z.string()).optional().describe("Filtros espec\xEDficos do dom\xEDnio"),
+        limit: z.number().int().min(1).max(100).default(20).describe("M\xE1x. de resultados (1-100, default 20)"),
+        offset: z.number().int().min(0).default(0).describe("Pula os N primeiros resultados (pagina\xE7\xE3o com limit)")
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async ({ domain, query, filters, limit, offset }, extra) => {
+      const d = findDomain(domain);
+      if (!d) return errorText(`Dom\xEDnio desconhecido: "${domain}". V\xE1lidos: ${validIds()}`);
+      if (filters) {
+        const valid = new Set(d.filters.map((f) => f.name));
+        const unknown = Object.keys(filters).filter((k) => !valid.has(k));
+        if (unknown.length > 0) {
+          return errorText(
+            `Filtros inv\xE1lidos para ${domain}: ${unknown.join(", ")}. V\xE1lidos: ${[...valid].join(", ")}`
+          );
+        }
+      }
+      const max = limit ?? 20;
+      const off = offset ?? 0;
+      if (d.live) {
+        if (!query?.trim()) {
+          return errorText(`O dom\xEDnio ${domain} \xE9 busca ao vivo: informe \`query\`.`);
+        }
+        try {
+          const results = await d.live.search(query, filters, extractContext(extra));
+          const page = results.slice(off, off + max);
+          return text({ matches: results.length, returned: page.length, results: page.map(compact) });
+        } catch (err) {
+          return errorText(
+            `Falha na busca ao vivo em ${domain}: ${err.message}. Tente novamente (dom\xEDnios ao vivo n\xE3o t\xEAm cache; refresh n\xE3o se aplica).`
+          );
+        }
+      }
+      try {
+        const { data, stale, extractedAt } = await getDomainData(d, false, extractContext(extra));
+        const results = d.search(data, query, filters);
+        const page = results.slice(off, off + max);
+        return text({
+          matches: results.length,
+          returned: page.length,
+          ...stale ? { stale: true, staleNote: `Fontes inacess\xEDveis; usando cache de ${extractedAt}` } : {},
+          ...results.length === 0 ? {
+            hint: 'Sem resultados; tente search(domain: "portal", query: ...) para buscar ao vivo em todo o Portal do Desenvolvedor.'
+          } : {},
+          results: page.map(compact)
+        });
+      } catch (err) {
+        return errorText(
+          `Falha ao obter dados de ${domain}: ${err.message}. Verifique a conex\xE3o com a internet e tente novamente (ou use a tool refresh).`
+        );
+      }
+    }
+  );
+  server2.registerTool(
+    "get_item",
+    {
+      title: "Detalhar um item",
+      description: "Devolve o registro completo de um item pelo `id` retornado por search (nos dom\xEDnios *-openapi e participantes inclui o n\xF3 integral da spec em `detail`).",
+      inputSchema: {
+        domain: domainIdSchema,
+        id: z.string().describe("Id do item (vindo de search)")
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async ({ domain, id }, extra) => {
+      const d = findDomain(domain);
+      if (!d) return errorText(`Dom\xEDnio desconhecido: "${domain}". V\xE1lidos: ${validIds()}`);
+      if (d.live) {
+        try {
+          const item = await d.live.getItem(id, extractContext(extra));
+          if (!item) {
+            return errorText(`Item n\xE3o encontrado em ${domain}: "${id}". Use search para descobrir ids.`);
+          }
+          return text(item);
+        } catch (err) {
+          return errorText(`Falha ao obter dados de ${domain}: ${err.message}.`);
+        }
+      }
+      try {
+        const { data, stale, extractedAt } = await getDomainData(d, false, extractContext(extra));
+        const item = d.getItem(data, id);
+        if (!item) {
+          return errorText(`Item n\xE3o encontrado em ${domain}: "${id}". Use search para descobrir ids.`);
+        }
+        return text(stale ? { stale: true, staleNote: `cache de ${extractedAt}`, item } : item);
+      } catch (err) {
+        return errorText(`Falha ao obter dados de ${domain}: ${err.message}.`);
+      }
+    }
+  );
+  server2.registerTool(
+    "refresh",
+    {
+      title: "Re-extrair fontes",
+      description: "For\xE7a re-extra\xE7\xE3o das fontes p\xFAblicas (ignora o TTL de 24h do cache). Sem `domain`, atualiza todos. Use quando suspeitar de dados desatualizados.",
+      inputSchema: {
+        domain: domainIdSchema.optional().describe("Id do dom\xEDnio; omita para todos")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    async ({ domain }, extra) => {
+      if (domain) {
+        const d = findDomain(domain);
+        if (!d) return errorText(`Dom\xEDnio desconhecido: "${domain}". V\xE1lidos: ${validIds()}`);
+        if (d.live) return errorText(`O dom\xEDnio ${domain} \xE9 busca ao vivo: n\xE3o h\xE1 cache para re-extrair.`);
+      }
+      const targets = domains.filter(
+        (d) => !d.live && (!domain || d.id === domain)
+      );
+      const report = {};
+      for (const d of targets) {
+        try {
+          const { data } = await getDomainData(d, true, extractContext(extra));
+          report[d.id] = `ok: ${data.items.length} itens`;
+        } catch (err) {
+          report[d.id] = `erro: ${err.message}`;
+        }
+      }
+      return text(report);
+    }
+  );
+  return server2;
+}
+
+// src/index.ts
+var server = createServer();
+await server.connect(new StdioServerTransport());
+console.error("[opf-br-mcp] server pronto (stdio)");

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "opf-br-mcp",
+  "version": "0.4.0",
+  "description": "MCP server local com as regras do Open Finance Brasil (PCM additionalInfo, specs OpenAPI de Pagamentos)",
+  "type": "module",
+  "license": "MIT",
+  "author": "jrogeriosilva",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "open-finance",
+    "open-banking",
+    "open-finance-brasil",
+    "openapi",
+    "pcm",
+    "pix"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jrogeriosilva/opf-br-mcp.git"
+  },
+  "homepage": "https://github.com/jrogeriosilva/opf-br-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/jrogeriosilva/opf-br-mcp/issues"
+  },
+  "bin": {
+    "opf-br-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.0",
+    "cheerio": "^1.0.0",
+    "yaml": "^2.5.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "domhandler": "^6.0.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^3.0.0"
+  }
+}