mcp-diagnostics 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,352 @@
+#!/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 dns from "dns/promises";
+import tls from "tls";
+import https from "https";
+import http from "http";
+import { URL } from "url";
+const L = process.env.MCP_DIAG_LICENSE_KEY || "";
+const isPro = () => L.startsWith("diag_pro_") && L.length > 20;
+const gate = () => isPro() ? null : "🔒 Pro feature. Get license: https://mcp-diagnostics.netlify.app";
+// === DNS Lookup ===
+async function dnsLookup(domain) {
+    const clean = domain.replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/:\d+$/, "");
+    const [a, aaaa, mx, txt, ns, cname, soa] = await Promise.allSettled([
+        dns.resolve4(clean),
+        dns.resolve6(clean),
+        dns.resolveMx(clean),
+        dns.resolveTxt(clean),
+        dns.resolveNs(clean),
+        dns.resolveCname(clean),
+        dns.resolveSoa(clean),
+    ]);
+    return {
+        domain: clean,
+        A: a.status === "fulfilled" ? a.value : [],
+        AAAA: aaaa.status === "fulfilled" ? aaaa.value : [],
+        MX: mx.status === "fulfilled" ? mx.value.sort((a, b) => a.priority - b.priority) : [],
+        TXT: txt.status === "fulfilled" ? txt.value.map(t => t.join("")) : [],
+        NS: ns.status === "fulfilled" ? ns.value : [],
+        CNAME: cname.status === "fulfilled" ? cname.value : [],
+        SOA: soa.status === "fulfilled" ? soa.value : null,
+    };
+}
+// === SSL Check ===
+function sslCheck(hostname) {
+    const clean = hostname.replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/:\d+$/, "");
+    return new Promise((resolve, reject) => {
+        const socket = tls.connect(443, clean, { servername: clean }, () => {
+            const cert = socket.getPeerCertificate();
+            const authorized = socket.authorized;
+            socket.end();
+            const validFrom = new Date(cert.valid_from);
+            const validTo = new Date(cert.valid_to);
+            const now = new Date();
+            const daysRemaining = Math.floor((validTo.getTime() - now.getTime()) / 86400000);
+            resolve({
+                hostname: clean,
+                valid: authorized,
+                issuer: cert.issuer,
+                subject: cert.subject,
+                validFrom: validFrom.toISOString(),
+                validTo: validTo.toISOString(),
+                daysRemaining,
+                serialNumber: cert.serialNumber,
+                fingerprint: cert.fingerprint256,
+                protocol: socket.getProtocol(),
+                warning: daysRemaining < 30 ? `⚠️ Certificate expires in ${daysRemaining} days!` : null,
+            });
+        });
+        socket.on("error", (e) => reject(new Error(`SSL error: ${e.message}`)));
+        socket.setTimeout(8000, () => { socket.destroy(); reject(new Error("SSL connection timeout")); });
+    });
+}
+// === HTTP Headers ===
+async function httpHeaders(url) {
+    const parsed = new URL(url.startsWith("http") ? url : `https://${url}`);
+    return new Promise((resolve, reject) => {
+        const mod = parsed.protocol === "https:" ? https : http;
+        const req = mod.request(parsed, { method: "HEAD", timeout: 8000 }, (res) => {
+            resolve({
+                url: parsed.href,
+                statusCode: res.statusCode,
+                statusMessage: res.statusMessage,
+                headers: res.headers,
+                server: res.headers["server"] || "unknown",
+                poweredBy: res.headers["x-powered-by"] || null,
+                contentType: res.headers["content-type"] || null,
+                cacheControl: res.headers["cache-control"] || null,
+            });
+        });
+        req.on("error", (e) => reject(new Error(`HTTP error: ${e.message}`)));
+        req.on("timeout", () => { req.destroy(); reject(new Error("Request timeout")); });
+        req.end();
+    });
+}
+// === Security Headers Check ===
+function analyzeSecurityHeaders(headers) {
+    const checks = [
+        { name: "Strict-Transport-Security", key: "strict-transport-security", critical: true },
+        { name: "Content-Security-Policy", key: "content-security-policy", critical: true },
+        { name: "X-Content-Type-Options", key: "x-content-type-options", critical: false },
+        { name: "X-Frame-Options", key: "x-frame-options", critical: false },
+        { name: "X-XSS-Protection", key: "x-xss-protection", critical: false },
+        { name: "Referrer-Policy", key: "referrer-policy", critical: false },
+        { name: "Permissions-Policy", key: "permissions-policy", critical: false },
+        { name: "Cross-Origin-Opener-Policy", key: "cross-origin-opener-policy", critical: false },
+        { name: "Cross-Origin-Resource-Policy", key: "cross-origin-resource-policy", critical: false },
+    ];
+    let score = 0;
+    const results = checks.map(check => {
+        const value = headers[check.key];
+        const present = !!value;
+        if (present)
+            score += check.critical ? 15 : 10;
+        return {
+            header: check.name,
+            present,
+            value: present ? String(value).substring(0, 100) : "❌ Missing",
+            critical: check.critical,
+        };
+    });
+    const grade = score >= 80 ? "A" : score >= 60 ? "B" : score >= 40 ? "C" : score >= 20 ? "D" : "F";
+    return { score, grade, maxScore: 100, results };
+}
+// === Ping / Uptime Check ===
+async function pingCheck(url) {
+    const parsed = new URL(url.startsWith("http") ? url : `https://${url}`);
+    const start = Date.now();
+    return new Promise((resolve, reject) => {
+        const mod = parsed.protocol === "https:" ? https : http;
+        const req = mod.request(parsed, { method: "GET", timeout: 10000 }, (res) => {
+            let size = 0;
+            res.on("data", (chunk) => { size += chunk.length; });
+            res.on("end", () => {
+                const responseTime = Date.now() - start;
+                resolve({
+                    url: parsed.href,
+                    status: res.statusCode,
+                    responseTime: `${responseTime}ms`,
+                    responseTimeMs: responseTime,
+                    contentLength: size,
+                    rating: responseTime < 200 ? "🟢 Excellent" : responseTime < 500 ? "🟡 Good" : responseTime < 1000 ? "🟠 Slow" : "🔴 Very Slow",
+                });
+            });
+        });
+        req.on("error", (e) => resolve({ url: parsed.href, status: "error", error: e.message, rating: "🔴 Down" }));
+        req.on("timeout", () => { req.destroy(); resolve({ url: parsed.href, status: "timeout", rating: "🔴 Timeout" }); });
+        req.end();
+    });
+}
+// === WHOIS (via RDAP - free public API) ===
+async function whoisLookup(domain) {
+    const clean = domain.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+    const res = await fetch(`https://rdap.org/domain/${clean}`, {
+        headers: { "Accept": "application/rdap+json" },
+        signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok)
+        throw new Error(`RDAP lookup failed: ${res.status}`);
+    const data = await res.json();
+    const events = (data.events || []).reduce((acc, e) => {
+        acc[e.eventAction] = e.eventDate;
+        return acc;
+    }, {});
+    return {
+        domain: data.ldhName || clean,
+        status: data.status || [],
+        registrar: data.entities?.find((e) => e.roles?.includes("registrar"))?.vcardArray?.[1]?.find((v) => v[0] === "fn")?.[3] || "unknown",
+        created: events.registration || null,
+        updated: events["last changed"] || null,
+        expires: events.expiration || null,
+        nameservers: (data.nameservers || []).map((ns) => ns.ldhName),
+    };
+}
+// === Tech Stack Detection ===
+function detectTechStack(headers) {
+    const server = String(headers["server"] || "").toLowerCase();
+    const powered = String(headers["x-powered-by"] || "").toLowerCase();
+    const via = String(headers["via"] || "").toLowerCase();
+    const all = Object.entries(headers).map(([k, v]) => `${k}: ${v}`).join("\n").toLowerCase();
+    const detected = [];
+    if (server.includes("nginx"))
+        detected.push("Nginx");
+    if (server.includes("apache"))
+        detected.push("Apache");
+    if (server.includes("cloudflare"))
+        detected.push("Cloudflare");
+    if (server.includes("vercel"))
+        detected.push("Vercel");
+    if (powered.includes("express"))
+        detected.push("Express.js");
+    if (powered.includes("next"))
+        detected.push("Next.js");
+    if (powered.includes("php"))
+        detected.push("PHP");
+    if (powered.includes("asp.net"))
+        detected.push("ASP.NET");
+    if (all.includes("x-amz"))
+        detected.push("AWS");
+    if (all.includes("x-goog"))
+        detected.push("Google Cloud");
+    if (all.includes("x-azure"))
+        detected.push("Azure");
+    if (all.includes("netlify"))
+        detected.push("Netlify");
+    if (all.includes("fly-request"))
+        detected.push("Fly.io");
+    if (headers["x-shopify-stage"])
+        detected.push("Shopify");
+    if (headers["x-wp-total"])
+        detected.push("WordPress");
+    return detected.length > 0 ? detected : ["Unknown"];
+}
+// === MCP Server ===
+const server = new McpServer({ name: "mcp-diagnostics", version: "1.0.0" });
+// --- FREE TOOLS ---
+server.tool("dns_lookup", "Look up DNS records for a domain. Returns A, AAAA, MX, TXT, NS, CNAME, SOA records. Free tool.", { domain: z.string().describe("Domain name (e.g., google.com, example.co.jp)") }, async ({ domain }) => {
+    try {
+        return { content: [{ type: "text", text: JSON.stringify(await dnsLookup(domain), null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+    }
+});
+server.tool("ssl_check", "Check SSL/TLS certificate for a domain. Shows issuer, expiry, days remaining, protocol. Warns if expiring soon. Free tool.", { hostname: z.string().describe("Domain name to check SSL (e.g., google.com)") }, async ({ hostname }) => {
+    try {
+        return { content: [{ type: "text", text: JSON.stringify(await sslCheck(hostname), null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+    }
+});
+server.tool("http_headers", "Fetch and analyze HTTP response headers. Shows server, caching, content type. Free tool.", { url: z.string().describe("URL to check (e.g., google.com or https://example.com)") }, async ({ url }) => {
+    try {
+        const result = await httpHeaders(url);
+        result.techStack = detectTechStack(result.headers);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+    }
+});
+server.tool("ping", "Check if a website is up and measure response time. Free tool.", { url: z.string().describe("URL to ping") }, async ({ url }) => {
+    try {
+        return { content: [{ type: "text", text: JSON.stringify(await pingCheck(url), null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+    }
+});
+// --- PRO TOOLS ---
+server.tool("security_scan", "🔒 [PRO] Full security headers audit with scoring (A-F grade). Checks HSTS, CSP, X-Frame-Options, and 6 more headers. Requires license.", { url: z.string().describe("URL to scan") }, async ({ url }) => {
+    const g = gate();
+    if (g)
+        return { content: [{ type: "text", text: g }] };
+    try {
+        const h = await httpHeaders(url);
+        const security = analyzeSecurityHeaders(h.headers);
+        return { content: [{ type: "text", text: JSON.stringify({
+                        url: h.url, statusCode: h.statusCode, ...security,
+                        recommendation: security.grade === "A" ? "Excellent security posture!" :
+                            security.grade === "B" ? "Good, but some headers are missing." :
+                                `Needs improvement. Add missing critical headers first.`
+                    }, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+    }
+});
+server.tool("whois", "🔒 [PRO] Domain WHOIS/RDAP lookup. Registration date, expiry, registrar, nameservers. Requires license.", { domain: z.string().describe("Domain to look up") }, async ({ domain }) => {
+    const g = gate();
+    if (g)
+        return { content: [{ type: "text", text: g }] };
+    try {
+        return { content: [{ type: "text", text: JSON.stringify(await whoisLookup(domain), null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+    }
+});
+server.tool("full_audit", "🔒 [PRO] Complete website audit: DNS + SSL + Headers + Security + Tech Stack + Performance in one call. Requires license.", { url: z.string().describe("URL to audit") }, async ({ url }) => {
+    const g = gate();
+    if (g)
+        return { content: [{ type: "text", text: g }] };
+    try {
+        const domain = url.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+        const [dnsResult, sslResult, headersResult, pingResult] = await Promise.allSettled([
+            dnsLookup(domain),
+            sslCheck(domain),
+            httpHeaders(url),
+            pingCheck(url),
+        ]);
+        const headers = headersResult.status === "fulfilled" ? headersResult.value.headers : {};
+        const security = analyzeSecurityHeaders(headers);
+        const techStack = detectTechStack(headers);
+        return { content: [{ type: "text", text: JSON.stringify({
+                        url, domain,
+                        dns: dnsResult.status === "fulfilled" ? dnsResult.value : { error: dnsResult.reason?.message },
+                        ssl: sslResult.status === "fulfilled" ? sslResult.value : { error: sslResult.reason?.message },
+                        http: headersResult.status === "fulfilled" ? { statusCode: headersResult.value.statusCode, server: headersResult.value.server } : { error: headersResult.reason?.message },
+                        performance: pingResult.status === "fulfilled" ? pingResult.value : { error: pingResult.reason?.message },
+                        security: { grade: security.grade, score: security.score },
+                        techStack,
+                        summary: `Security: ${security.grade} | SSL: ${sslResult.status === "fulfilled" ? sslResult.value.daysRemaining + " days" : "error"} | Response: ${pingResult.status === "fulfilled" ? pingResult.value.responseTime : "error"}`
+                    }, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+    }
+});
+server.tool("compare_sites", "🔒 [PRO] Compare two websites side by side: performance, security, SSL, tech stack. Requires license.", {
+    url1: z.string().describe("First URL"),
+    url2: z.string().describe("Second URL"),
+}, async ({ url1, url2 }) => {
+    const g = gate();
+    if (g)
+        return { content: [{ type: "text", text: g }] };
+    try {
+        const [p1, p2, h1, h2, s1, s2] = await Promise.allSettled([
+            pingCheck(url1), pingCheck(url2),
+            httpHeaders(url1), httpHeaders(url2),
+            sslCheck(url1.replace(/^https?:\/\//, "").replace(/\/.*$/, "")),
+            sslCheck(url2.replace(/^https?:\/\//, "").replace(/\/.*$/, "")),
+        ]);
+        const sec1 = h1.status === "fulfilled" ? analyzeSecurityHeaders(h1.value.headers) : null;
+        const sec2 = h2.status === "fulfilled" ? analyzeSecurityHeaders(h2.value.headers) : null;
+        return { content: [{ type: "text", text: JSON.stringify({
+                        comparison: {
+                            [url1]: {
+                                responseTime: p1.status === "fulfilled" ? p1.value.responseTime : "error",
+                                securityGrade: sec1?.grade || "?",
+                                sslDaysRemaining: s1.status === "fulfilled" ? s1.value.daysRemaining : "error",
+                                techStack: h1.status === "fulfilled" ? detectTechStack(h1.value.headers) : [],
+                            },
+                            [url2]: {
+                                responseTime: p2.status === "fulfilled" ? p2.value.responseTime : "error",
+                                securityGrade: sec2?.grade || "?",
+                                sslDaysRemaining: s2.status === "fulfilled" ? s2.value.daysRemaining : "error",
+                                techStack: h2.status === "fulfilled" ? detectTechStack(h2.value.headers) : [],
+                            },
+                        },
+                        winner: {
+                            faster: p1.status === "fulfilled" && p2.status === "fulfilled"
+                                ? (p1.value.responseTimeMs < p2.value.responseTimeMs ? url1 : url2)
+                                : "unknown",
+                            moreSecure: (sec1?.score || 0) > (sec2?.score || 0) ? url1 : (sec1?.score || 0) < (sec2?.score || 0) ? url2 : "tie",
+                        }
+                    }, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+    }
+});
+// === Start ===
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("mcp-diagnostics v1.0.0 running");
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "mcp-diagnostics",
+  "version": "1.0.0",
+  "description": "Website & Server Diagnostics MCP Server. DNS, SSL, HTTP headers, security scan, performance audit.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": { "mcp-diagnostics": "dist/index.js" },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["mcp","diagnostics","dns","ssl","security","performance","devops","seo","lighthouse","website","audit","modelcontextprotocol","claude"],
+  "author": "HatoTools",
+  "license": "MIT",
+  "homepage": "https://github.com/kame6493-del/mcp-diagnostics",
+  "repository": { "type": "git", "url": "https://github.com/kame6493-del/mcp-diagnostics.git" },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "typescript": "^5.8.3"
+  }
+}