domains-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fulldev
+
+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,78 @@
+# domains-mcp
+
+An MCP server that lets Claude (and other agents) check **domain availability**, look up
+registration details, and suggest available names across TLDs.
+
+Availability comes entirely from **free, open protocols** — [RDAP](https://www.rfc-editor.org/rfc/rfc9224)
+with a port-43 **WHOIS** fallback. No API keys, no accounts, no paid services.
+
+## Tools
+
+| Tool | What it does |
+| --- | --- |
+| `check_domain` | Is a single domain available? Accepts bare names, URLs, and IDNs. |
+| `check_domains` | Bulk-check a list of domains (max 50, runs concurrently). |
+| `suggest_domains` | Given a base name, return the available options across a set of TLDs. |
+| `domain_info` | Registrar, status, creation/expiry dates, and nameservers for a domain. |
+
+Each result is one of `available`, `registered`, or `unknown`. `unknown` means no source could
+answer definitively — the server never guesses an answer.
+
+## Install & build
+
+```bash
+npm install
+npm run build
+```
+
+## Quick smoke test (no MCP client needed)
+
+```bash
+node dist/cli-smoke.js google.com some-free-name-12345.com github.io münchen.de
+```
+
+## Use with Claude
+
+Add to your MCP client configuration (e.g. Claude Desktop's `claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "domains": {
+      "command": "node",
+      "args": ["/absolute/path/to/domains-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+Then ask things like: *"Is acme-robotics.com available?"*, *"Check these five domains for me,"* or
+*"Suggest available domains for the name 'lumina'."*
+
+## Configuration (all optional)
+
+| Variable | Purpose | Default |
+| --- | --- | --- |
+| `REQUEST_TIMEOUT_MS` | Per-request network timeout | `5000` |
+| `CACHE_TTL_SECONDS` | TTL for the in-memory availability cache | `300` |
+| `CONCURRENCY` | Max concurrent lookups during bulk operations | `8` |
+| `DEFAULT_TLDS` | Comma-separated TLDs used by `suggest_domains` | `com,net,org,io,ai,co,dev,app,xyz,me` |
+
+## How it works
+
+1. The input domain is normalized (URL stripping, `www.` removal, IDN → Punycode, validation).
+2. **RDAP**: the TLD is resolved to its RDAP server via the IANA bootstrap registry. A `404` means
+   available; a `200` returns full registration data.
+3. **WHOIS fallback**: if the TLD has no RDAP service (or RDAP is inconclusive), the server asks
+   IANA for the TLD's WHOIS server, queries it, and pattern-matches the response.
+4. Results are cached briefly to cut latency and respect registry rate limits.
+
+## Known limitations
+
+Some ccTLD WHOIS servers (e.g. DENIC for `.de`) return restricted or unusually formatted
+responses; those may come back as `unknown` rather than a guess. RDAP/WHOIS report registration
+status, not whether a taken domain is for sale.
+
+## License
+
+MIT

package/dist/cli-smoke.js

@@ -0,0 +1,16 @@
+/** Quick manual smoke test: `node dist/cli-smoke.js example.com google.com xn--test.io` */
+import { loadConfig } from "./config.js";
+import { DomainService } from "./service.js";
+async function main() {
+    const args = process.argv.slice(2);
+    const domains = args.length ? args : ["google.com", "this-name-is-almost-certainly-free-12345.com"];
+    const service = new DomainService(loadConfig());
+    const results = await service.checkMany(domains);
+    for (const r of results) {
+        console.log(JSON.stringify(r));
+    }
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/config.js

@@ -0,0 +1,34 @@
+const DEFAULT_TLDS = [
+    "com",
+    "net",
+    "org",
+    "io",
+    "ai",
+    "co",
+    "dev",
+    "app",
+    "xyz",
+    "me",
+];
+function intFromEnv(name, fallback) {
+    const raw = process.env[name];
+    if (!raw)
+        return fallback;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+export function loadConfig() {
+    const tldsRaw = process.env.DEFAULT_TLDS;
+    const defaultTlds = tldsRaw
+        ? tldsRaw
+            .split(",")
+            .map((t) => t.trim().replace(/^\./, "").toLowerCase())
+            .filter(Boolean)
+        : DEFAULT_TLDS;
+    return {
+        requestTimeoutMs: intFromEnv("REQUEST_TIMEOUT_MS", 5000),
+        cacheTtlSeconds: intFromEnv("CACHE_TTL_SECONDS", 300),
+        concurrency: intFromEnv("CONCURRENCY", 8),
+        defaultTlds,
+    };
+}

package/dist/index.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { loadConfig } from "./config.js";
+import { DomainService } from "./service.js";
+const config = loadConfig();
+const service = new DomainService(config);
+const server = new McpServer({
+    name: "domains-mcp",
+    version: "0.1.0",
+});
+function statusLine(r) {
+    const name = r.domainUnicode !== r.domain ? `${r.domainUnicode} (${r.domain})` : r.domain;
+    switch (r.availability) {
+        case "available":
+            return `✅ ${name} — AVAILABLE`;
+        case "registered": {
+            const exp = r.registration?.expiryDate
+                ? `, expires ${r.registration.expiryDate.slice(0, 10)}`
+                : "";
+            const reg = r.registration?.registrar ? ` via ${r.registration.registrar}` : "";
+            return `❌ ${name} — registered${reg}${exp}`;
+        }
+        default:
+            return `❓ ${name} — UNKNOWN (${r.reason ?? "no definitive answer"})`;
+    }
+}
+function asResult(text, structured) {
+    return {
+        content: [{ type: "text", text }],
+        structuredContent: { result: structured },
+    };
+}
+server.tool("check_domain", "Check whether a single domain is available to register. Uses RDAP (authoritative, free) with a WHOIS fallback. Returns available | registered | unknown.", { domain: z.string().describe('A domain name, e.g. "example.com". URLs and IDNs are accepted.') }, async ({ domain }) => {
+    const r = await service.checkOne(domain);
+    return asResult(statusLine(r), r);
+});
+server.tool("check_domains", "Check availability for a list of domains at once (bulk). Runs concurrently. Returns one result per domain.", {
+    domains: z
+        .array(z.string())
+        .min(1)
+        .max(50)
+        .describe("List of domain names to check (max 50)."),
+}, async ({ domains }) => {
+    const results = await service.checkMany(domains);
+    const text = results.map(statusLine).join("\n");
+    return asResult(text, results);
+});
+server.tool("suggest_domains", "Given a base name (the part before the dot), check it across a set of TLDs and return only the available ones. Useful for brainstorming a name across .com/.io/.ai/etc.", {
+    name: z.string().describe('The label to check, e.g. "acme" (no TLD).'),
+    tlds: z
+        .array(z.string())
+        .optional()
+        .describe("TLDs to try (without dots). Defaults to a common set if omitted."),
+}, async ({ name, tlds }) => {
+    const results = await service.suggest(name, tlds);
+    const text = results.length
+        ? `Available options for "${name}":\n` + results.map(statusLine).join("\n")
+        : `No available domains found for "${name}" in the checked TLDs.`;
+    return asResult(text, results);
+});
+server.tool("domain_info", "Look up registration details (registrar, status, creation/expiry dates, nameservers) for a domain via RDAP. If the domain is unregistered, reports that it is available.", { domain: z.string().describe("The domain to look up.") }, async ({ domain }) => {
+    const r = await service.checkOne(domain);
+    let text = statusLine(r);
+    if (r.availability === "registered" && r.registration) {
+        const reg = r.registration;
+        const lines = [
+            reg.registrar ? `Registrar: ${reg.registrar}` : null,
+            reg.statuses?.length ? `Status: ${reg.statuses.join(", ")}` : null,
+            reg.createdDate ? `Created: ${reg.createdDate}` : null,
+            reg.updatedDate ? `Updated: ${reg.updatedDate}` : null,
+            reg.expiryDate ? `Expires: ${reg.expiryDate}` : null,
+            reg.nameservers?.length ? `Nameservers: ${reg.nameservers.join(", ")}` : null,
+        ].filter(Boolean);
+        text += "\n" + lines.join("\n");
+    }
+    return asResult(text, r);
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Logs must go to stderr; stdout is the MCP transport.
+    console.error("domains-mcp running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/dist/lib/bootstrap.js

@@ -0,0 +1,53 @@
+import { fetchWithTimeout } from "./cache.js";
+/**
+ * IANA RDAP bootstrap. Maps a TLD to the RDAP base URL(s) that serve it.
+ * Spec: https://datatracker.ietf.org/doc/html/rfc9224
+ * Data: https://data.iana.org/rdap/dns.json
+ */
+const BOOTSTRAP_URL = "https://data.iana.org/rdap/dns.json";
+const BOOTSTRAP_TTL_MS = 24 * 60 * 60 * 1000; // 1 day
+let cache = null;
+let inflight = null;
+async function loadBootstrap(timeoutMs) {
+    if (cache && cache.expires > Date.now())
+        return cache.map;
+    if (inflight)
+        return inflight;
+    inflight = (async () => {
+        const res = await fetchWithTimeout(BOOTSTRAP_URL, timeoutMs, {
+            headers: { accept: "application/json" },
+        });
+        if (!res.ok) {
+            throw new Error(`RDAP bootstrap fetch failed: HTTP ${res.status}`);
+        }
+        const data = (await res.json());
+        const map = new Map();
+        for (const [tlds, urls] of data.services) {
+            const bases = urls.map((u) => u.replace(/\/$/, ""));
+            for (const tld of tlds) {
+                map.set(tld.toLowerCase(), bases);
+            }
+        }
+        cache = { map, expires: Date.now() + BOOTSTRAP_TTL_MS };
+        return map;
+    })();
+    try {
+        return await inflight;
+    }
+    finally {
+        inflight = null;
+    }
+}
+/** Returns the RDAP base URLs for a TLD, or null if the TLD has no RDAP. */
+export async function rdapBaseForTld(tld, timeoutMs) {
+    const map = await loadBootstrap(timeoutMs);
+    // For multi-label TLDs (e.g. "co.uk") fall back to the last label.
+    const direct = map.get(tld.toLowerCase());
+    if (direct)
+        return direct;
+    const lastLabel = tld.split(".").pop();
+    if (lastLabel && lastLabel !== tld) {
+        return map.get(lastLabel.toLowerCase()) ?? null;
+    }
+    return null;
+}

package/dist/lib/cache.js

@@ -0,0 +1,61 @@
+/** A tiny in-memory TTL cache with a bounded size (simple LRU-ish eviction). */
+export class TtlCache {
+    ttlMs;
+    maxEntries;
+    store = new Map();
+    constructor(ttlMs, maxEntries = 5000) {
+        this.ttlMs = ttlMs;
+        this.maxEntries = maxEntries;
+    }
+    get(key) {
+        const hit = this.store.get(key);
+        if (!hit)
+            return undefined;
+        if (hit.expires < Date.now()) {
+            this.store.delete(key);
+            return undefined;
+        }
+        // Refresh recency.
+        this.store.delete(key);
+        this.store.set(key, hit);
+        return hit.value;
+    }
+    set(key, value) {
+        if (this.ttlMs <= 0)
+            return;
+        if (this.store.size >= this.maxEntries) {
+            const oldest = this.store.keys().next().value;
+            if (oldest !== undefined)
+                this.store.delete(oldest);
+        }
+        this.store.set(key, { value, expires: Date.now() + this.ttlMs });
+    }
+}
+/** Run async tasks with bounded concurrency, preserving input order. */
+export async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    let cursor = 0;
+    const workers = new Array(Math.max(1, Math.min(limit, items.length)))
+        .fill(0)
+        .map(async () => {
+        while (true) {
+            const index = cursor++;
+            if (index >= items.length)
+                return;
+            results[index] = await fn(items[index], index);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
+/** fetch() with a timeout via AbortController. */
+export async function fetchWithTimeout(url, timeoutMs, init = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/lib/normalize.js

@@ -0,0 +1,54 @@
+import { domainToASCII, domainToUnicode } from "node:url";
+const LABEL_RE = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+/**
+ * Accepts user input that may be a bare domain, a URL, or an IDN, and returns
+ * a normalized form. Throws on input that cannot be a valid domain.
+ */
+export function normalizeDomain(input) {
+    if (!input || typeof input !== "string") {
+        throw new Error("Domain is required.");
+    }
+    let value = input.trim().toLowerCase();
+    // Strip a scheme + path if the user passed a URL.
+    if (value.includes("://")) {
+        try {
+            value = new URL(value).hostname;
+        }
+        catch {
+            throw new Error(`Could not parse "${input}" as a domain or URL.`);
+        }
+    }
+    else {
+        // Strip any stray path/query (e.g. "example.com/foo").
+        value = value.split("/")[0].split("?")[0];
+    }
+    // Drop a leading "www." for the purpose of availability checks.
+    value = value.replace(/^www\./, "");
+    // Drop a trailing dot (fully-qualified form).
+    value = value.replace(/\.$/, "");
+    if (!value.includes(".")) {
+        throw new Error(`"${input}" is missing a TLD (expected something like "example.com").`);
+    }
+    const ascii = domainToASCII(value);
+    if (!ascii) {
+        throw new Error(`"${input}" is not a valid domain name.`);
+    }
+    const unicode = domainToUnicode(ascii);
+    const firstDot = ascii.indexOf(".");
+    const label = ascii.slice(0, firstDot);
+    const tld = ascii.slice(firstDot + 1);
+    if (!label || !tld) {
+        throw new Error(`"${input}" is not a well-formed domain name.`);
+    }
+    // Validate each label looks like a hostname label.
+    for (const part of ascii.split(".")) {
+        if (!LABEL_RE.test(part)) {
+            throw new Error(`"${input}" contains an invalid label: "${part}".`);
+        }
+    }
+    return { ascii, unicode, label, tld };
+}
+/** Build an ascii domain from a label + tld, normalizing IDN. */
+export function buildDomain(label, tld) {
+    return normalizeDomain(`${label}.${tld.replace(/^\./, "")}`);
+}

package/dist/providers/provider.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/rdap.js

@@ -0,0 +1,86 @@
+import { domainToUnicode } from "node:url";
+import { fetchWithTimeout } from "../lib/cache.js";
+import { rdapBaseForTld } from "../lib/bootstrap.js";
+function extractRegistrar(data) {
+    const reg = data.entities?.find((e) => e.roles?.includes("registrar"));
+    if (!reg)
+        return undefined;
+    // vcardArray is ["vcard", [ ["fn", {}, "text", "Registrar Name"], ... ]]
+    const vcard = reg.vcardArray;
+    const fn = vcard?.[1]?.find((entry) => entry[0] === "fn");
+    return fn?.[3];
+}
+function extractEvent(data, action) {
+    return data.events?.find((e) => e.eventAction === action)?.eventDate;
+}
+function toRegistrationInfo(data) {
+    return {
+        registrar: extractRegistrar(data),
+        statuses: data.status,
+        createdDate: extractEvent(data, "registration"),
+        updatedDate: extractEvent(data, "last changed"),
+        expiryDate: extractEvent(data, "expiration"),
+        nameservers: data.nameservers
+            ?.map((n) => n.ldhName)
+            .filter((n) => Boolean(n)),
+    };
+}
+export class RdapProvider {
+    timeoutMs;
+    name = "rdap";
+    constructor(timeoutMs) {
+        this.timeoutMs = timeoutMs;
+    }
+    async checkAvailability(ascii, tld) {
+        const unicode = domainToUnicode(ascii);
+        const base = { domain: ascii, domainUnicode: unicode, source: this.name };
+        let bases;
+        try {
+            bases = await rdapBaseForTld(tld, this.timeoutMs);
+        }
+        catch (err) {
+            return {
+                ...base,
+                availability: "unknown",
+                reason: `RDAP bootstrap unavailable: ${err.message}`,
+            };
+        }
+        if (!bases || bases.length === 0) {
+            return {
+                ...base,
+                availability: "unknown",
+                reason: `No RDAP service is published for ".${tld}".`,
+            };
+        }
+        let lastError = "";
+        for (const baseUrl of bases) {
+            const url = `${baseUrl}/domain/${encodeURIComponent(ascii)}`;
+            try {
+                const res = await fetchWithTimeout(url, this.timeoutMs, {
+                    headers: { accept: "application/rdap+json, application/json" },
+                });
+                if (res.status === 404) {
+                    return { ...base, availability: "available" };
+                }
+                if (res.ok) {
+                    const data = (await res.json());
+                    return {
+                        ...base,
+                        availability: "registered",
+                        registration: toRegistrationInfo(data),
+                    };
+                }
+                // 429/5xx etc: try the next base, but remember the error.
+                lastError = `HTTP ${res.status} from ${baseUrl}`;
+            }
+            catch (err) {
+                lastError = `${err.message} (${baseUrl})`;
+            }
+        }
+        return {
+            ...base,
+            availability: "unknown",
+            reason: `RDAP lookup did not return a definitive answer: ${lastError}`,
+        };
+    }
+}

package/dist/providers/whois.js

@@ -0,0 +1,106 @@
+import net from "node:net";
+import { domainToUnicode } from "node:url";
+const IANA_WHOIS = "whois.iana.org";
+const WHOIS_PORT = 43;
+/** Phrases that indicate a domain is NOT registered (available). */
+const FREE_PATTERNS = [
+    /\bno match\b/i,
+    /\bnot found\b/i,
+    /\bno data found\b/i,
+    /\bno entries found\b/i,
+    /\bnot registered\b/i,
+    /\bavailable for registration\b/i,
+    /\bstatus:\s*free\b/i,
+    /\bstatus:\s*available\b/i,
+    /\bdomain not found\b/i,
+    /^\s*no object found/im,
+];
+/** Phrases that indicate a domain IS registered. */
+const TAKEN_PATTERNS = [
+    /^domain name:/im,
+    /^domain:\s*\S/im, // DENIC (.de) and others echo "Domain: <name>" only when taken
+    /\bregistrar:/i,
+    /\bcreation date:/i,
+    /\bcreated:/i,
+    /\bregistry domain id:/i,
+    /\bname server:/i,
+    /\bnserver:/i,
+    /\bstatus:\s*(active|connect|ok|registered)\b/i,
+];
+function queryWhois(host, query, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection(WHOIS_PORT, host);
+        let data = "";
+        socket.setTimeout(timeoutMs);
+        socket.on("connect", () => socket.write(`${query}\r\n`));
+        socket.on("data", (chunk) => (data += chunk.toString("utf8")));
+        socket.on("end", () => resolve(data));
+        socket.on("timeout", () => {
+            socket.destroy();
+            reject(new Error(`WHOIS timeout querying ${host}`));
+        });
+        socket.on("error", (err) => reject(err));
+    });
+}
+/** Find the authoritative WHOIS server for a TLD by asking IANA. */
+async function whoisServerForTld(tld, timeoutMs) {
+    const lastLabel = tld.split(".").pop() ?? tld;
+    const response = await queryWhois(IANA_WHOIS, lastLabel, timeoutMs);
+    const match = response.match(/^\s*whois:\s*(\S+)\s*$/im);
+    return match ? match[1].trim() : null;
+}
+function classify(text) {
+    // Free patterns win first (a "no match" body may still contain stray keywords).
+    if (FREE_PATTERNS.some((re) => re.test(text)))
+        return "available";
+    if (TAKEN_PATTERNS.some((re) => re.test(text)))
+        return "registered";
+    return "unknown";
+}
+export class WhoisProvider {
+    timeoutMs;
+    name = "whois";
+    constructor(timeoutMs) {
+        this.timeoutMs = timeoutMs;
+    }
+    async checkAvailability(ascii, tld) {
+        const unicode = domainToUnicode(ascii);
+        const base = { domain: ascii, domainUnicode: unicode, source: this.name };
+        let server;
+        try {
+            server = await whoisServerForTld(tld, this.timeoutMs);
+        }
+        catch (err) {
+            return {
+                ...base,
+                availability: "unknown",
+                reason: `Could not resolve WHOIS server for ".${tld}": ${err.message}`,
+            };
+        }
+        if (!server) {
+            return {
+                ...base,
+                availability: "unknown",
+                reason: `No WHOIS server is published for ".${tld}".`,
+            };
+        }
+        try {
+            const text = await queryWhois(server, ascii, this.timeoutMs);
+            const availability = classify(text);
+            return {
+                ...base,
+                availability,
+                reason: availability === "unknown"
+                    ? `WHOIS response from ${server} was inconclusive.`
+                    : undefined,
+            };
+        }
+        catch (err) {
+            return {
+                ...base,
+                availability: "unknown",
+                reason: `WHOIS query to ${server} failed: ${err.message}`,
+            };
+        }
+    }
+}

package/dist/service.js

@@ -0,0 +1,61 @@
+import { TtlCache, mapWithConcurrency } from "./lib/cache.js";
+import { normalizeDomain, buildDomain } from "./lib/normalize.js";
+import { RdapProvider } from "./providers/rdap.js";
+import { WhoisProvider } from "./providers/whois.js";
+/**
+ * Orchestrates the providers: RDAP first, WHOIS fallback when RDAP returns
+ * "unknown" (e.g. a TLD without RDAP), plus a short-TTL cache.
+ */
+export class DomainService {
+    config;
+    rdap;
+    whois;
+    cache;
+    constructor(config) {
+        this.config = config;
+        this.rdap = new RdapProvider(config.requestTimeoutMs);
+        this.whois = new WhoisProvider(config.requestTimeoutMs);
+        this.cache = new TtlCache(config.cacheTtlSeconds * 1000);
+    }
+    async checkOne(input) {
+        const { ascii, tld } = normalizeDomain(input);
+        const cached = this.cache.get(ascii);
+        if (cached)
+            return cached;
+        let result = await this.rdap.checkAvailability(ascii, tld);
+        // Fall back to WHOIS only when RDAP couldn't give a definitive answer.
+        if (result.availability === "unknown") {
+            const whoisResult = await this.whois.checkAvailability(ascii, tld);
+            if (whoisResult.availability !== "unknown") {
+                result = whoisResult;
+            }
+            else {
+                // Keep the richer RDAP reason but note both were tried.
+                result = {
+                    ...result,
+                    source: "rdap+whois",
+                    reason: `${result.reason ?? "RDAP inconclusive."} WHOIS also inconclusive: ${whoisResult.reason ?? ""}`.trim(),
+                };
+            }
+        }
+        this.cache.set(ascii, result);
+        return result;
+    }
+    async checkMany(inputs) {
+        return mapWithConcurrency(inputs, this.config.concurrency, (d) => this.checkOne(d).catch((err) => ({
+            domain: d,
+            domainUnicode: d,
+            availability: "unknown",
+            source: "error",
+            reason: err.message,
+        })));
+    }
+    /** Expand a label across TLDs and return only the available ones. */
+    async suggest(name, tlds) {
+        const label = name.trim().toLowerCase().replace(/\.$/, "");
+        const useTlds = (tlds && tlds.length ? tlds : this.config.defaultTlds).map((t) => t.replace(/^\./, "").toLowerCase());
+        const domains = useTlds.map((tld) => buildDomain(label, tld).ascii);
+        const results = await this.checkMany(domains);
+        return results.filter((r) => r.availability === "available");
+    }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "domains-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for checking domain availability via RDAP (with WHOIS fallback). Free, no API keys.",
+  "type": "module",
+  "bin": {
+    "domains-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "check": "node dist/cli-smoke.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "domain",
+    "availability",
+    "rdap",
+    "whois",
+    "claude"
+  ],
+  "author": "fulldev",
+  "license": "MIT",
+  "homepage": "https://github.com/fulldev-pl1/domains-mcp#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fulldev-pl1/domains-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fulldev-pl1/domains-mcp/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0"
+  }
+}