registro-br-mcp 1.0.0

package/README.md

@@ -0,0 +1,124 @@
+# Registro.br MCP Server
+
+Um servidor [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) para consultar o RDAP do Registro.br.
+
+## Ferramentas Disponíveis
+
+| Ferramenta | Descrição |
+|------------|-----------|
+| `rdap_domain` | Consulta informações de domínios .br (ex: `nic.br`, `registro.br`) |
+| `rdap_entity` | Consulta entidades por CNPJ, CPF ou handle (ex: `05506560000136`, `FAN`) |
+| `rdap_nameserver` | Consulta informações de nameservers (ex: `a.dns.br`) |
+| `rdap_ip` | Consulta informações de IP ou rede (ex: `200.160.0.0`, `200.160.0.0/20`) |
+| `rdap_asn` | Consulta Autonomous System Numbers (ex: `22548`, `AS22548`) |
+
+## Instalação
+
+### Via npx (recomendado)
+
+Não é necessário instalar. Configure diretamente no seu cliente MCP.
+
+### Via npm (global)
+
+```bash
+npm install -g registro-br-mcp
+```
+
+## Configuração
+
+### Claude Desktop
+
+Adicione ao arquivo de configuração (`~/Library/Application Support/Claude/claude_desktop_config.json` no macOS):
+
+```json
+{
+  "mcpServers": {
+    "registro-br": {
+      "command": "npx",
+      "args": ["registro-br-mcp"]
+    }
+  }
+}
+```
+
+### Claude Code
+
+Adicione ao arquivo `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "registro-br": {
+      "command": "npx",
+      "args": ["registro-br-mcp"]
+    }
+  }
+}
+```
+
+## Exemplos de Uso
+
+Após configurar, você pode fazer perguntas como:
+
+- "Consulte o domínio nic.br"
+- "Quem é o registrante do domínio registro.br?"
+- "Busque informações do ASN 22548"
+- "Qual o IP do nameserver a.dns.br?"
+- "Consulte a entidade com CNPJ 05506560000136"
+
+## Exemplo de Resposta
+
+Consulta do domínio `nic.br`:
+
+```
+Domain: nic.br
+Handle: nic.br
+Status: active
+
+Events:
+  - registration: 1997-07-11T12:00:00Z
+  - last changed: 2018-03-27T20:09:08Z
+
+Nameservers:
+  - a.dns.br
+  - b.dns.br
+  - c.dns.br
+  - d.dns.br
+  - e.dns.br
+
+DNSSEC: Signed
+  - KeyTag: 47828, Algorithm: 13, DigestType: 2
+
+Entities:
+  - Núcleo de Inf. e Coord. do Ponto BR - NIC.BR (registrant)
+  - Frederico Augusto de Carvalho Neves (technical)
+```
+
+## API RDAP
+
+Este servidor utiliza a API RDAP pública do Registro.br:
+
+- Base URL: `https://rdap.registro.br`
+- Documentação: https://registro.br/rdap/
+
+## Desenvolvimento
+
+```bash
+# Clonar o repositório
+git clone https://github.com/yvesmariano/registro-br-mcp.git
+cd registro-br-mcp
+
+# Instalar dependências
+npm install
+
+# Executar localmente
+npm start
+```
+
+## Requisitos
+
+- Node.js >= 18.0.0
+
+## Licença
+
+MIT

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "registro-br-mcp",
+  "version": "1.0.0",
+  "description": "MCP Server para consultar o RDAP do Registro.br",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "registro-br-mcp": "./src/index.js"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.0"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "rdap",
+    "registro.br",
+    "whois",
+    "domain",
+    "brasil",
+    "brazil"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yvesmariano/registro-br-mcp.git"
+  },
+  "author": "Yves Mariano",
+  "homepage": "https://github.com/yvesmariano/registro-br-mcp#readme"
+}

package/src/index.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+const RDAP_BASE_URL = "https://rdap.registro.br";
+
+async function fetchRdap(path) {
+  const url = `${RDAP_BASE_URL}${path}`;
+  const response = await fetch(url, {
+    headers: {
+      Accept: "application/rdap+json",
+    },
+  });
+
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(`Not found: ${path}`);
+    }
+    throw new Error(`RDAP request failed: ${response.status} ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+function formatDomainInfo(data) {
+  const lines = [];
+
+  lines.push(`Domain: ${data.ldhName}`);
+  lines.push(`Handle: ${data.handle}`);
+  lines.push(`Status: ${data.status?.join(", ") || "N/A"}`);
+
+  if (data.events) {
+    lines.push("\nEvents:");
+    for (const event of data.events) {
+      lines.push(`  - ${event.eventAction}: ${event.eventDate}`);
+    }
+  }
+
+  if (data.nameservers) {
+    lines.push("\nNameservers:");
+    for (const ns of data.nameservers) {
+      lines.push(`  - ${ns.ldhName}`);
+    }
+  }
+
+  if (data.secureDNS) {
+    lines.push(`\nDNSSEC: ${data.secureDNS.delegationSigned ? "Signed" : "Not signed"}`);
+    if (data.secureDNS.dsData) {
+      for (const ds of data.secureDNS.dsData) {
+        lines.push(`  - KeyTag: ${ds.keyTag}, Algorithm: ${ds.algorithm}, DigestType: ${ds.digestType}`);
+      }
+    }
+  }
+
+  if (data.entities) {
+    lines.push("\nEntities:");
+    for (const entity of data.entities) {
+      const name = entity.vcardArray?.[1]?.find(v => v[0] === "fn")?.[3] || entity.handle;
+      lines.push(`  - ${name} (${entity.roles?.join(", ") || "N/A"})`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function formatEntityInfo(data) {
+  const lines = [];
+
+  lines.push(`Handle: ${data.handle}`);
+
+  if (data.vcardArray) {
+    const vcard = data.vcardArray[1];
+    const fn = vcard.find(v => v[0] === "fn")?.[3];
+    const email = vcard.find(v => v[0] === "email")?.[3];
+    const kind = vcard.find(v => v[0] === "kind")?.[3];
+
+    if (fn) lines.push(`Name: ${fn}`);
+    if (kind) lines.push(`Type: ${kind}`);
+    if (email) lines.push(`Email: ${email}`);
+  }
+
+  if (data.roles) {
+    lines.push(`Roles: ${data.roles.join(", ")}`);
+  }
+
+  if (data.publicIds) {
+    lines.push("\nPublic IDs:");
+    for (const pid of data.publicIds) {
+      lines.push(`  - ${pid.type}: ${pid.identifier}`);
+    }
+  }
+
+  if (data.events) {
+    lines.push("\nEvents:");
+    for (const event of data.events) {
+      lines.push(`  - ${event.eventAction}: ${event.eventDate}`);
+    }
+  }
+
+  if (data.legalRepresentative) {
+    lines.push(`\nLegal Representative: ${data.legalRepresentative}`);
+  }
+
+  return lines.join("\n");
+}
+
+function formatNameserverInfo(data) {
+  const lines = [];
+
+  lines.push(`Nameserver: ${data.ldhName}`);
+  lines.push(`Handle: ${data.handle || "N/A"}`);
+
+  if (data.ipAddresses) {
+    if (data.ipAddresses.v4) {
+      lines.push(`IPv4: ${data.ipAddresses.v4.join(", ")}`);
+    }
+    if (data.ipAddresses.v6) {
+      lines.push(`IPv6: ${data.ipAddresses.v6.join(", ")}`);
+    }
+  }
+
+  if (data.events) {
+    lines.push("\nEvents:");
+    for (const event of data.events) {
+      lines.push(`  - ${event.eventAction}: ${event.eventDate}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function formatIpInfo(data) {
+  const lines = [];
+
+  lines.push(`Handle: ${data.handle}`);
+  lines.push(`Start Address: ${data.startAddress}`);
+  lines.push(`End Address: ${data.endAddress}`);
+  lines.push(`IP Version: ${data.ipVersion}`);
+  lines.push(`Name: ${data.name || "N/A"}`);
+  lines.push(`Type: ${data.type || "N/A"}`);
+  lines.push(`Country: ${data.country || "N/A"}`);
+
+  if (data.status) {
+    lines.push(`Status: ${data.status.join(", ")}`);
+  }
+
+  if (data.events) {
+    lines.push("\nEvents:");
+    for (const event of data.events) {
+      lines.push(`  - ${event.eventAction}: ${event.eventDate}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function formatAsnInfo(data) {
+  const lines = [];
+
+  lines.push(`Handle: ${data.handle}`);
+  lines.push(`Start ASN: ${data.startAutnum}`);
+  lines.push(`End ASN: ${data.endAutnum}`);
+  lines.push(`Name: ${data.name || "N/A"}`);
+  lines.push(`Type: ${data.type || "N/A"}`);
+  lines.push(`Country: ${data.country || "N/A"}`);
+
+  if (data.status) {
+    lines.push(`Status: ${data.status.join(", ")}`);
+  }
+
+  if (data.events) {
+    lines.push("\nEvents:");
+    for (const event of data.events) {
+      lines.push(`  - ${event.eventAction}: ${event.eventDate}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+const server = new McpServer({
+  name: "registro-br-rdap",
+  version: "1.0.0",
+});
+
+// Tool: Query domain information
+server.tool(
+  "rdap_domain",
+  "Query RDAP information for a .br domain",
+  {
+    domain: z.string().describe("The domain name to query (e.g., nic.br, registro.br)"),
+  },
+  async ({ domain }) => {
+    try {
+      const data = await fetchRdap(`/domain/${domain}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatDomainInfo(data),
+          },
+          {
+            type: "text",
+            text: "\n\n--- Raw JSON ---\n" + JSON.stringify(data, null, 2),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error querying domain: ${error.message}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Tool: Query entity information
+server.tool(
+  "rdap_entity",
+  "Query RDAP information for an entity (by CNPJ, CPF, or handle)",
+  {
+    entity: z.string().describe("The entity identifier (CNPJ without punctuation, CPF, or handle like 'FAN')"),
+  },
+  async ({ entity }) => {
+    try {
+      const data = await fetchRdap(`/entity/${entity}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatEntityInfo(data),
+          },
+          {
+            type: "text",
+            text: "\n\n--- Raw JSON ---\n" + JSON.stringify(data, null, 2),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error querying entity: ${error.message}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Tool: Query nameserver information
+server.tool(
+  "rdap_nameserver",
+  "Query RDAP information for a nameserver",
+  {
+    nameserver: z.string().describe("The nameserver hostname (e.g., a.dns.br)"),
+  },
+  async ({ nameserver }) => {
+    try {
+      const data = await fetchRdap(`/nameserver/${nameserver}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatNameserverInfo(data),
+          },
+          {
+            type: "text",
+            text: "\n\n--- Raw JSON ---\n" + JSON.stringify(data, null, 2),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error querying nameserver: ${error.message}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Tool: Query IP network information
+server.tool(
+  "rdap_ip",
+  "Query RDAP information for an IP address or network",
+  {
+    ip: z.string().describe("The IP address or CIDR notation (e.g., 200.160.0.0, 200.160.0.0/20)"),
+  },
+  async ({ ip }) => {
+    try {
+      const data = await fetchRdap(`/ip/${ip}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatIpInfo(data),
+          },
+          {
+            type: "text",
+            text: "\n\n--- Raw JSON ---\n" + JSON.stringify(data, null, 2),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error querying IP: ${error.message}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Tool: Query ASN information
+server.tool(
+  "rdap_asn",
+  "Query RDAP information for an Autonomous System Number",
+  {
+    asn: z.string().describe("The AS number (e.g., 22548 or AS22548)"),
+  },
+  async ({ asn }) => {
+    try {
+      const asnNumber = asn.replace(/^AS/i, "");
+      const data = await fetchRdap(`/autnum/${asnNumber}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatAsnInfo(data),
+          },
+          {
+            type: "text",
+            text: "\n\n--- Raw JSON ---\n" + JSON.stringify(data, null, 2),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error querying ASN: ${error.message}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Registro.br RDAP MCP Server running on stdio");
+}
+
+main().catch(console.error);