@rog0x/mcp-network-tools 1.0.0

package/dist/tools/ssl-checker.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSsl = checkSsl;
+const tls = __importStar(require("node:tls"));
+function checkSsl(host, port = 443) {
+    return new Promise((resolve, reject) => {
+        const socket = tls.connect({
+            host,
+            port,
+            servername: host,
+            rejectUnauthorized: false,
+            timeout: 10000,
+        }, () => {
+            const cert = socket.getPeerCertificate(true);
+            const cipher = socket.getCipher();
+            const protocol = socket.getProtocol();
+            const authorized = socket.authorized;
+            if (!cert || !cert.subject) {
+                socket.destroy();
+                reject(new Error("No certificate returned by server"));
+                return;
+            }
+            const validTo = new Date(cert.valid_to);
+            const now = new Date();
+            const daysUntilExpiry = Math.floor((validTo.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+            const altNames = cert.subjectaltname
+                ? cert.subjectaltname.split(", ").map((s) => s.replace("DNS:", ""))
+                : [];
+            const chain = [];
+            let current = cert;
+            const seen = new Set();
+            while (current && current.issuerCertificate && !seen.has(current.fingerprint256)) {
+                seen.add(current.fingerprint256);
+                const issuerCert = current.issuerCertificate;
+                const subjectCN = issuerCert.subject?.CN;
+                const issuerCN = issuerCert.issuer?.CN;
+                chain.push({
+                    subject: (Array.isArray(subjectCN) ? subjectCN[0] : subjectCN) || "Unknown",
+                    issuer: (Array.isArray(issuerCN) ? issuerCN[0] : issuerCN) || "Unknown",
+                    validTo: issuerCert.valid_to,
+                });
+                if (issuerCert.fingerprint256 === current.fingerprint256)
+                    break;
+                current = issuerCert;
+            }
+            const result = {
+                host,
+                valid: authorized && daysUntilExpiry > 0,
+                issuer: cert.issuer,
+                subject: cert.subject,
+                validFrom: cert.valid_from,
+                validTo: cert.valid_to,
+                daysUntilExpiry,
+                serialNumber: cert.serialNumber,
+                fingerprint: cert.fingerprint,
+                fingerprint256: cert.fingerprint256,
+                subjectAltNames: altNames,
+                protocol: protocol || "unknown",
+                cipher: cipher?.name || "unknown",
+                chain,
+                timestamp: new Date().toISOString(),
+            };
+            socket.destroy();
+            resolve(result);
+        });
+        socket.on("error", (err) => {
+            socket.destroy();
+            reject(err);
+        });
+        socket.on("timeout", () => {
+            socket.destroy();
+            reject(new Error("Connection timed out"));
+        });
+    });
+}
+//# sourceMappingURL=ssl-checker.js.map

package/dist/tools/whois-lookup.d.ts

@@ -0,0 +1,16 @@
+interface WhoisResult {
+    domain: string;
+    raw: string;
+    parsed: {
+        registrar: string;
+        creationDate: string;
+        expiryDate: string;
+        updatedDate: string;
+        nameServers: string[];
+        status: string[];
+        registrant: string;
+    };
+    timestamp: string;
+}
+export declare function whoisLookup(domain: string): Promise<WhoisResult>;
+export {};

package/dist/tools/whois-lookup.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whoisLookup = whoisLookup;
+const net = __importStar(require("node:net"));
+function queryWhoisServer(server, query) {
+    return new Promise((resolve, reject) => {
+        const socket = new net.Socket();
+        let data = "";
+        socket.setTimeout(10000);
+        socket.connect(43, server, () => {
+            socket.write(query + "\r\n");
+        });
+        socket.on("data", (chunk) => {
+            data += chunk.toString();
+        });
+        socket.on("end", () => {
+            resolve(data);
+        });
+        socket.on("timeout", () => {
+            socket.destroy();
+            reject(new Error(`WHOIS query to ${server} timed out`));
+        });
+        socket.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+function extractField(raw, patterns) {
+    for (const pattern of patterns) {
+        const regex = new RegExp(`${pattern}:\\s*(.+)`, "im");
+        const match = raw.match(regex);
+        if (match)
+            return match[1].trim();
+    }
+    return "";
+}
+function extractMulti(raw, patterns) {
+    const results = [];
+    for (const pattern of patterns) {
+        const regex = new RegExp(`${pattern}:\\s*(.+)`, "gim");
+        let match;
+        while ((match = regex.exec(raw)) !== null) {
+            const value = match[1].trim();
+            if (value && !results.includes(value)) {
+                results.push(value);
+            }
+        }
+    }
+    return results;
+}
+function getWhoisServer(tld) {
+    const servers = {
+        com: "whois.verisign-grs.com",
+        net: "whois.verisign-grs.com",
+        org: "whois.pir.org",
+        info: "whois.afilias.net",
+        io: "whois.nic.io",
+        dev: "whois.nic.google",
+        app: "whois.nic.google",
+        co: "whois.nic.co",
+        me: "whois.nic.me",
+        ai: "whois.nic.ai",
+        xyz: "whois.nic.xyz",
+        tech: "whois.nic.tech",
+    };
+    return servers[tld] || "whois.iana.org";
+}
+async function whoisLookup(domain) {
+    const parts = domain.split(".");
+    const tld = parts[parts.length - 1].toLowerCase();
+    const server = getWhoisServer(tld);
+    let raw = await queryWhoisServer(server, domain);
+    // Check for referral to another WHOIS server
+    const referralMatch = raw.match(/Whois Server:\s*(.+)/im);
+    if (referralMatch) {
+        const referralServer = referralMatch[1].trim();
+        if (referralServer !== server) {
+            try {
+                const referralData = await queryWhoisServer(referralServer, domain);
+                if (referralData.length > raw.length) {
+                    raw = referralData;
+                }
+            }
+            catch {
+                // Use original data if referral fails
+            }
+        }
+    }
+    const parsed = {
+        registrar: extractField(raw, ["Registrar", "Sponsoring Registrar"]),
+        creationDate: extractField(raw, [
+            "Creation Date",
+            "Created Date",
+            "Created",
+            "Registration Date",
+        ]),
+        expiryDate: extractField(raw, [
+            "Registry Expiry Date",
+            "Registrar Registration Expiration Date",
+            "Expiry Date",
+            "Expiration Date",
+        ]),
+        updatedDate: extractField(raw, [
+            "Updated Date",
+            "Last Updated",
+            "Last Modified",
+        ]),
+        nameServers: extractMulti(raw, ["Name Server", "Nameserver", "nserver"]),
+        status: extractMulti(raw, ["Domain Status", "Status"]),
+        registrant: extractField(raw, [
+            "Registrant Organization",
+            "Registrant Name",
+            "Registrant",
+        ]),
+    };
+    return {
+        domain,
+        raw,
+        parsed,
+        timestamp: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=whois-lookup.js.map

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@rog0x/mcp-network-tools",
+  "version": "1.0.0",
+  "description": "Network diagnostics tools for AI agents via MCP",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "keywords": ["mcp", "network", "diagnostics", "dns", "ssl", "whois", "ping"],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { dnsLookup, reverseDns, checkPropagation } from "./tools/dns-lookup.js";
+import { getIpInfo } from "./tools/ip-info.js";
+import { checkSsl } from "./tools/ssl-checker.js";
+import { whoisLookup } from "./tools/whois-lookup.js";
+import { httpPing } from "./tools/ping-tool.js";
+
+const server = new Server(
+  {
+    name: "mcp-network-tools",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "dns_lookup",
+      description:
+        "Resolve a domain name to DNS records (A, AAAA, MX, TXT, NS, CNAME, SOA). Supports reverse DNS and propagation checking.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          domain: {
+            type: "string",
+            description: "Domain name to look up (e.g. example.com)",
+          },
+          record_types: {
+            type: "array",
+            items: { type: "string" },
+            description:
+              "Record types to query (default: all). Options: A, AAAA, MX, TXT, NS, CNAME, SOA",
+          },
+          mode: {
+            type: "string",
+            enum: ["resolve", "reverse", "propagation"],
+            description:
+              "Mode: 'resolve' (default) for forward DNS, 'reverse' for reverse DNS (pass IP in domain), 'propagation' to check across public DNS servers",
+          },
+        },
+        required: ["domain"],
+      },
+    },
+    {
+      name: "ip_info",
+      description:
+        "Get geolocation and network information for an IP address: country, city, ISP, ASN, coordinates. Supports IPv4 and IPv6.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          ip: {
+            type: "string",
+            description: "IPv4 or IPv6 address to look up",
+          },
+        },
+        required: ["ip"],
+      },
+    },
+    {
+      name: "ssl_check",
+      description:
+        "Check the SSL/TLS certificate of a host: validity, issuer, expiry date, days until expiry, subject alternative names, certificate chain, cipher, and protocol.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          host: {
+            type: "string",
+            description: "Hostname to check (e.g. example.com)",
+          },
+          port: {
+            type: "number",
+            description: "Port number (default: 443)",
+          },
+        },
+        required: ["host"],
+      },
+    },
+    {
+      name: "whois_lookup",
+      description:
+        "Look up WHOIS information for a domain: registrar, creation date, expiry date, nameservers, and domain status.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          domain: {
+            type: "string",
+            description: "Domain name to look up (e.g. example.com)",
+          },
+        },
+        required: ["domain"],
+      },
+    },
+    {
+      name: "http_ping",
+      description:
+        "Measure HTTP response time to a URL over multiple requests. Returns per-request latency and statistics: average, min, max, p95, and success rate.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          url: {
+            type: "string",
+            description: "URL to ping (e.g. https://example.com)",
+          },
+          count: {
+            type: "number",
+            description: "Number of requests to send (default: 5, max: 20)",
+          },
+          timeout_ms: {
+            type: "number",
+            description: "Timeout per request in milliseconds (default: 10000)",
+          },
+        },
+        required: ["url"],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case "dns_lookup": {
+        const domain = args?.domain as string;
+        const mode = (args?.mode as string) || "resolve";
+        const recordTypes = args?.record_types as string[] | undefined;
+
+        let result: unknown;
+        switch (mode) {
+          case "reverse":
+            result = await reverseDns(domain);
+            break;
+          case "propagation":
+            result = await checkPropagation(
+              domain,
+              recordTypes?.[0] || "A"
+            );
+            break;
+          default:
+            result = await dnsLookup(domain, recordTypes);
+            break;
+        }
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+      }
+
+      case "ip_info": {
+        const result = await getIpInfo(args?.ip as string);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+      }
+
+      case "ssl_check": {
+        const port = (args?.port as number) || 443;
+        const result = await checkSsl(args?.host as string, port);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+      }
+
+      case "whois_lookup": {
+        const result = await whoisLookup(args?.domain as string);
+        // Return parsed data without the full raw WHOIS by default to save tokens
+        const { raw, ...summary } = result;
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                { ...summary, rawLength: raw.length },
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      }
+
+      case "http_ping": {
+        const count = (args?.count as number) || 5;
+        const timeoutMs = (args?.timeout_ms as number) || 10000;
+        const result = await httpPing(args?.url as string, count, timeoutMs);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Error: ${message}` }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("MCP Network Tools server running on stdio");
+}
+
+main().catch(console.error);

package/src/tools/dns-lookup.ts

@@ -0,0 +1,131 @@
+import * as dns from "node:dns";
+import { promisify } from "node:util";
+
+const resolve4 = promisify(dns.resolve4);
+const resolve6 = promisify(dns.resolve6);
+const resolveMx = promisify(dns.resolveMx);
+const resolveTxt = promisify(dns.resolveTxt);
+const resolveNs = promisify(dns.resolveNs);
+const resolveCname = promisify(dns.resolveCname);
+const resolveSoa = promisify(dns.resolveSoa);
+const reverseLookup = promisify(dns.reverse);
+
+interface DnsLookupResult {
+  domain: string;
+  records: Record<string, unknown>;
+  timestamp: string;
+}
+
+interface ReverseDnsResult {
+  ip: string;
+  hostnames: string[];
+  timestamp: string;
+}
+
+async function safeResolve<T>(fn: () => Promise<T>): Promise<T | null> {
+  try {
+    return await fn();
+  } catch {
+    return null;
+  }
+}
+
+export async function dnsLookup(
+  domain: string,
+  recordTypes?: string[]
+): Promise<DnsLookupResult> {
+  const types = recordTypes?.map((t) => t.toUpperCase()) ?? [
+    "A",
+    "AAAA",
+    "MX",
+    "TXT",
+    "NS",
+    "CNAME",
+    "SOA",
+  ];
+
+  const records: Record<string, unknown> = {};
+
+  const resolvers: Record<string, () => Promise<unknown>> = {
+    A: () => resolve4(domain),
+    AAAA: () => resolve6(domain),
+    MX: () => resolveMx(domain),
+    TXT: () => resolveTxt(domain),
+    NS: () => resolveNs(domain),
+    CNAME: () => resolveCname(domain),
+    SOA: () => resolveSoa(domain),
+  };
+
+  await Promise.all(
+    types.map(async (type) => {
+      const resolver = resolvers[type];
+      if (resolver) {
+        const result = await safeResolve(resolver);
+        if (result !== null) {
+          records[type] = result;
+        }
+      }
+    })
+  );
+
+  return {
+    domain,
+    records,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export async function reverseDns(ip: string): Promise<ReverseDnsResult> {
+  const hostnames = await reverseLookup(ip);
+  return {
+    ip,
+    hostnames,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export async function checkPropagation(
+  domain: string,
+  recordType: string = "A"
+): Promise<{
+  domain: string;
+  recordType: string;
+  servers: Record<string, unknown>;
+  consistent: boolean;
+  timestamp: string;
+}> {
+  const dnsServers: Record<string, string> = {
+    "Google": "8.8.8.8",
+    "Cloudflare": "1.1.1.1",
+    "OpenDNS": "208.67.222.222",
+    "Quad9": "9.9.9.9",
+  };
+
+  const resolver = new dns.Resolver();
+  const resolveWithServer = promisify(resolver.resolve.bind(resolver));
+
+  const results: Record<string, unknown> = {};
+  const allRecords: string[] = [];
+
+  for (const [name, server] of Object.entries(dnsServers)) {
+    try {
+      resolver.setServers([server]);
+      const records = await resolveWithServer(domain, recordType);
+      results[name] = { server, records };
+      allRecords.push(JSON.stringify(records));
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      results[name] = { server, error: message };
+    }
+  }
+
+  const uniqueResults = new Set(allRecords);
+
+  return {
+    domain,
+    recordType,
+    servers: results,
+    consistent: uniqueResults.size <= 1,
+    timestamp: new Date().toISOString(),
+  };
+}