@rog0x/mcp-network-tools 1.0.0

package/src/tools/ip-info.ts

@@ -0,0 +1,71 @@
+import http from "node:http";
+
+interface IpInfoResult {
+  ip: string;
+  country: string;
+  countryCode: string;
+  region: string;
+  regionName: string;
+  city: string;
+  zip: string;
+  lat: number;
+  lon: number;
+  timezone: string;
+  isp: string;
+  org: string;
+  as: string;
+  asn: string;
+  query: string;
+  timestamp: string;
+}
+
+function httpGet(url: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const req = http.get(url, { timeout: 10000 }, (res) => {
+      let data = "";
+      res.on("data", (chunk: Buffer) => {
+        data += chunk.toString();
+      });
+      res.on("end", () => resolve(data));
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+  });
+}
+
+export async function getIpInfo(ip: string): Promise<IpInfoResult> {
+  const url = `http://ip-api.com/json/${encodeURIComponent(ip)}?fields=status,message,country,countryCode,region,regionName,city,zip,lat,lon,timezone,isp,org,as,query`;
+
+  const raw = await httpGet(url);
+  const data = JSON.parse(raw);
+
+  if (data.status === "fail") {
+    throw new Error(`IP lookup failed: ${data.message}`);
+  }
+
+  const asString = (data.as as string) || "";
+  const asnMatch = asString.match(/^AS(\d+)/);
+
+  return {
+    ip,
+    country: data.country ?? "",
+    countryCode: data.countryCode ?? "",
+    region: data.region ?? "",
+    regionName: data.regionName ?? "",
+    city: data.city ?? "",
+    zip: data.zip ?? "",
+    lat: data.lat ?? 0,
+    lon: data.lon ?? 0,
+    timezone: data.timezone ?? "",
+    isp: data.isp ?? "",
+    org: data.org ?? "",
+    as: asString,
+    asn: asnMatch ? `AS${asnMatch[1]}` : "",
+    query: data.query ?? ip,
+    timestamp: new Date().toISOString(),
+  };
+}

package/src/tools/ping-tool.ts

@@ -0,0 +1,122 @@
+import https from "node:https";
+import http from "node:http";
+import { URL } from "node:url";
+
+interface PingResult {
+  url: string;
+  requests: number;
+  results: Array<{
+    attempt: number;
+    statusCode: number;
+    latencyMs: number;
+  }>;
+  stats: {
+    avgMs: number;
+    minMs: number;
+    maxMs: number;
+    p95Ms: number;
+    successRate: number;
+  };
+  timestamp: string;
+}
+
+function singlePing(
+  url: string,
+  timeoutMs: number
+): Promise<{ statusCode: number; latencyMs: number }> {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const client = parsed.protocol === "https:" ? https : http;
+    const start = performance.now();
+
+    const req = client.get(
+      url,
+      {
+        timeout: timeoutMs,
+        headers: {
+          "User-Agent": "mcp-network-tools/1.0",
+        },
+      },
+      (res) => {
+        const latencyMs = Math.round((performance.now() - start) * 100) / 100;
+        // Consume response data to free memory
+        res.resume();
+        res.on("end", () => {
+          resolve({
+            statusCode: res.statusCode || 0,
+            latencyMs,
+          });
+        });
+      }
+    );
+
+    req.on("error", (err) => {
+      reject(err);
+    });
+
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+  });
+}
+
+function percentile(sorted: number[], p: number): number {
+  const index = Math.ceil((p / 100) * sorted.length) - 1;
+  return sorted[Math.max(0, index)];
+}
+
+export async function httpPing(
+  url: string,
+  count: number = 5,
+  timeoutMs: number = 10000
+): Promise<PingResult> {
+  const safeCount = Math.min(Math.max(1, count), 20);
+
+  const results: Array<{
+    attempt: number;
+    statusCode: number;
+    latencyMs: number;
+  }> = [];
+
+  for (let i = 0; i < safeCount; i++) {
+    try {
+      const { statusCode, latencyMs } = await singlePing(url, timeoutMs);
+      results.push({ attempt: i + 1, statusCode, latencyMs });
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      results.push({ attempt: i + 1, statusCode: 0, latencyMs: -1 });
+    }
+  }
+
+  const successfulLatencies = results
+    .filter((r) => r.latencyMs >= 0)
+    .map((r) => r.latencyMs)
+    .sort((a, b) => a - b);
+
+  const successCount = successfulLatencies.length;
+
+  const stats = {
+    avgMs:
+      successCount > 0
+        ? Math.round(
+            (successfulLatencies.reduce((a, b) => a + b, 0) / successCount) *
+              100
+          ) / 100
+        : -1,
+    minMs: successCount > 0 ? successfulLatencies[0] : -1,
+    maxMs:
+      successCount > 0 ? successfulLatencies[successCount - 1] : -1,
+    p95Ms: successCount > 0 ? percentile(successfulLatencies, 95) : -1,
+    successRate:
+      Math.round((successCount / safeCount) * 10000) / 100,
+  };
+
+  return {
+    url,
+    requests: safeCount,
+    results,
+    stats,
+    timestamp: new Date().toISOString(),
+  };
+}

package/src/tools/ssl-checker.ts

@@ -0,0 +1,112 @@
+import * as tls from "node:tls";
+import * as net from "node:net";
+
+interface CertificateInfo {
+  host: string;
+  valid: boolean;
+  issuer: Record<string, string>;
+  subject: Record<string, string>;
+  validFrom: string;
+  validTo: string;
+  daysUntilExpiry: number;
+  serialNumber: string;
+  fingerprint: string;
+  fingerprint256: string;
+  subjectAltNames: string[];
+  protocol: string;
+  cipher: string;
+  chain: Array<{
+    subject: string;
+    issuer: string;
+    validTo: string;
+  }>;
+  timestamp: string;
+}
+
+export function checkSsl(
+  host: string,
+  port: number = 443
+): Promise<CertificateInfo> {
+  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: string) => s.replace("DNS:", ""))
+          : [];
+
+        const chain: Array<{ subject: string; issuer: string; validTo: string }> =
+          [];
+        let current = cert;
+        const seen = new Set<string>();
+        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: CertificateInfo = {
+          host,
+          valid: authorized && daysUntilExpiry > 0,
+          issuer: cert.issuer as unknown as Record<string, string>,
+          subject: cert.subject as unknown as Record<string, string>,
+          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"));
+    });
+  });
+}

package/src/tools/whois-lookup.ts

@@ -0,0 +1,147 @@
+import * as net from "node:net";
+
+interface WhoisResult {
+  domain: string;
+  raw: string;
+  parsed: {
+    registrar: string;
+    creationDate: string;
+    expiryDate: string;
+    updatedDate: string;
+    nameServers: string[];
+    status: string[];
+    registrant: string;
+  };
+  timestamp: string;
+}
+
+function queryWhoisServer(server: string, query: string): Promise<string> {
+  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: Buffer) => {
+      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: string, patterns: string[]): string {
+  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: string, patterns: string[]): string[] {
+  const results: string[] = [];
+  for (const pattern of patterns) {
+    const regex = new RegExp(`${pattern}:\\s*(.+)`, "gim");
+    let match: RegExpExecArray | null;
+    while ((match = regex.exec(raw)) !== null) {
+      const value = match[1].trim();
+      if (value && !results.includes(value)) {
+        results.push(value);
+      }
+    }
+  }
+  return results;
+}
+
+function getWhoisServer(tld: string): string {
+  const servers: Record<string, string> = {
+    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";
+}
+
+export async function whoisLookup(domain: string): Promise<WhoisResult> {
+  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(),
+  };
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"]
+}