@rog0x/mcp-api-tools 1.0.0

package/src/index.ts

@@ -0,0 +1,308 @@
+#!/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 { httpRequest } from "./tools/http-request.js";
+import { apiHealth } from "./tools/api-health.js";
+import { jwtDecode } from "./tools/jwt-decode.js";
+import { parseUrl, buildUrl } from "./tools/url-parser.js";
+import { analyzeHeaders } from "./tools/header-analyzer.js";
+
+const server = new Server(
+  {
+    name: "mcp-api-tools",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "http_request",
+      description:
+        "Make an HTTP request with full control over method, headers, body, authentication, and timeouts. Returns status, headers, body, and timing information.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          method: {
+            type: "string",
+            description: "HTTP method: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS",
+          },
+          url: {
+            type: "string",
+            description: "The full URL to send the request to",
+          },
+          headers: {
+            type: "object",
+            description: "Key-value pairs of HTTP headers to include",
+            additionalProperties: { type: "string" },
+          },
+          body: {
+            type: "string",
+            description: "Request body (for POST, PUT, PATCH)",
+          },
+          timeout: {
+            type: "number",
+            description: "Request timeout in milliseconds (default: 30000)",
+          },
+          follow_redirects: {
+            type: "boolean",
+            description: "Whether to follow redirects (default: true)",
+          },
+          auth: {
+            type: "object",
+            description: "Authentication configuration",
+            properties: {
+              type: {
+                type: "string",
+                enum: ["basic", "bearer"],
+                description: "Auth type: basic or bearer",
+              },
+              username: { type: "string", description: "Username for basic auth" },
+              password: { type: "string", description: "Password for basic auth" },
+              token: { type: "string", description: "Token for bearer auth" },
+            },
+            required: ["type"],
+          },
+        },
+        required: ["method", "url"],
+      },
+    },
+    {
+      name: "api_health",
+      description:
+        "Check the health of multiple API endpoints. Returns status, response time, SSL certificate validity, and optional response body validation for each endpoint.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          endpoints: {
+            type: "array",
+            description: "Array of endpoints to check (max 20)",
+            items: {
+              type: "object",
+              properties: {
+                url: { type: "string", description: "Endpoint URL" },
+                expected_status: {
+                  type: "number",
+                  description: "Expected HTTP status code (default: 200)",
+                },
+                expected_body_contains: {
+                  type: "string",
+                  description: "String the response body must contain",
+                },
+              },
+              required: ["url"],
+            },
+          },
+        },
+        required: ["endpoints"],
+      },
+    },
+    {
+      name: "jwt_decode",
+      description:
+        "Decode a JWT token without verification. Returns header, payload, expiry, issued-at time, and whether the token is expired.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          token: {
+            type: "string",
+            description: "The JWT token string to decode",
+          },
+        },
+        required: ["token"],
+      },
+    },
+    {
+      name: "url_parse",
+      description:
+        "Parse a URL into its component parts: protocol, host, port, path, query parameters, hash, and more. Can also build a URL from parts.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          url: {
+            type: "string",
+            description: "URL to parse (use this OR build_params, not both)",
+          },
+          build_params: {
+            type: "object",
+            description: "Build a URL from parts instead of parsing",
+            properties: {
+              protocol: { type: "string", description: "Protocol (default: https:)" },
+              hostname: { type: "string", description: "Hostname (required)" },
+              port: { type: "string", description: "Port number" },
+              pathname: { type: "string", description: "Path (default: /)" },
+              query_params: {
+                type: "object",
+                description: "Query parameters as key-value pairs",
+                additionalProperties: {
+                  oneOf: [
+                    { type: "string" },
+                    { type: "array", items: { type: "string" } },
+                  ],
+                },
+              },
+              hash: { type: "string", description: "Hash/fragment" },
+              username: { type: "string", description: "URL username" },
+              password: { type: "string", description: "URL password" },
+            },
+            required: ["hostname"],
+          },
+        },
+      },
+    },
+    {
+      name: "header_analyzer",
+      description:
+        "Analyze HTTP response headers for security (HSTS, CSP, X-Frame-Options, etc.), caching directives, CORS configuration, cookies, and server information. Provides a security grade.",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          headers: {
+            type: "object",
+            description: "HTTP response headers as key-value pairs to analyze",
+            additionalProperties: { type: "string" },
+          },
+          url: {
+            type: "string",
+            description:
+              "Alternatively, provide a URL to fetch and analyze its response headers",
+          },
+        },
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case "http_request": {
+        const result = await httpRequest({
+          method: args?.method as string,
+          url: args?.url as string,
+          headers: args?.headers as Record<string, string> | undefined,
+          body: args?.body as string | undefined,
+          timeout: args?.timeout as number | undefined,
+          follow_redirects: args?.follow_redirects as boolean | undefined,
+          auth: args?.auth as {
+            type: "basic" | "bearer";
+            username?: string;
+            password?: string;
+            token?: string;
+          } | undefined,
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+      }
+
+      case "api_health": {
+        const endpoints = args?.endpoints as Array<{
+          url: string;
+          expected_status?: number;
+          expected_body_contains?: string;
+        }>;
+        const result = await apiHealth(endpoints);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+      }
+
+      case "jwt_decode": {
+        const result = jwtDecode(args?.token as string);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+      }
+
+      case "url_parse": {
+        if (args?.build_params) {
+          const built = buildUrl(
+            args.build_params as {
+              protocol?: string;
+              hostname: string;
+              port?: string | number;
+              pathname?: string;
+              query_params?: Record<string, string | string[]>;
+              hash?: string;
+              username?: string;
+              password?: string;
+            }
+          );
+          return {
+            content: [
+              { type: "text", text: JSON.stringify({ built_url: built }, null, 2) },
+            ],
+          };
+        }
+        if (args?.url) {
+          const parsed = parseUrl(args.url as string);
+          return {
+            content: [{ type: "text", text: JSON.stringify(parsed, null, 2) }],
+          };
+        }
+        throw new Error("Provide either 'url' to parse or 'build_params' to build");
+      }
+
+      case "header_analyzer": {
+        if (args?.url) {
+          const controller = new AbortController();
+          const timer = setTimeout(() => controller.abort(), 15000);
+          try {
+            const response = await fetch(args.url as string, {
+              method: "HEAD",
+              signal: controller.signal,
+              redirect: "follow",
+            });
+            const fetchedHeaders: Record<string, string> = {};
+            response.headers.forEach((value, key) => {
+              fetchedHeaders[key] = value;
+            });
+            const result = analyzeHeaders(fetchedHeaders);
+            return {
+              content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+          } finally {
+            clearTimeout(timer);
+          }
+        }
+        if (args?.headers) {
+          const result = analyzeHeaders(args.headers as Record<string, string>);
+          return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          };
+        }
+        throw new Error("Provide either 'headers' object or 'url' to fetch headers from");
+      }
+
+      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 API Tools server running on stdio");
+}
+
+main().catch(console.error);

package/src/tools/api-health.ts

@@ -0,0 +1,179 @@
+import * as tls from "node:tls";
+import * as https from "node:https";
+
+export interface HealthEndpoint {
+  url: string;
+  expected_status?: number;
+  expected_body_contains?: string;
+}
+
+export interface EndpointHealth {
+  url: string;
+  status: "healthy" | "unhealthy" | "error";
+  http_status: number | null;
+  response_time_ms: number;
+  ssl: SslInfo | null;
+  body_valid: boolean | null;
+  error: string | null;
+}
+
+export interface SslInfo {
+  valid: boolean;
+  issuer: string;
+  subject: string;
+  expires: string;
+  days_remaining: number;
+}
+
+function checkSsl(hostname: string, port: number): Promise<SslInfo | null> {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      socket.destroy();
+      resolve(null);
+    }, 5000);
+
+    const socket = tls.connect({ host: hostname, port, servername: hostname }, () => {
+      clearTimeout(timeout);
+      const cert = socket.getPeerCertificate();
+      if (!cert || !cert.valid_to) {
+        socket.destroy();
+        resolve(null);
+        return;
+      }
+
+      const expiresDate = new Date(cert.valid_to);
+      const now = new Date();
+      const daysRemaining = Math.floor(
+        (expiresDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24)
+      );
+
+      const flatten = (val: string | string[] | undefined): string => {
+        if (!val) return "Unknown";
+        return Array.isArray(val) ? val[0] : val;
+      };
+
+      resolve({
+        valid: socket.authorized,
+        issuer:
+          typeof cert.issuer === "object"
+            ? flatten(cert.issuer.O) !== "Unknown"
+              ? flatten(cert.issuer.O)
+              : flatten(cert.issuer.CN)
+            : "Unknown",
+        subject:
+          typeof cert.subject === "object"
+            ? flatten(cert.subject.CN)
+            : "Unknown",
+        expires: cert.valid_to,
+        days_remaining: daysRemaining,
+      });
+
+      socket.destroy();
+    });
+
+    socket.on("error", () => {
+      clearTimeout(timeout);
+      resolve(null);
+    });
+  });
+}
+
+async function checkEndpoint(endpoint: HealthEndpoint): Promise<EndpointHealth> {
+  const { url, expected_status = 200, expected_body_contains } = endpoint;
+
+  let parsedUrl: URL;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    return {
+      url,
+      status: "error",
+      http_status: null,
+      response_time_ms: 0,
+      ssl: null,
+      body_valid: null,
+      error: "Invalid URL",
+    };
+  }
+
+  const isHttps = parsedUrl.protocol === "https:";
+  const sslPromise = isHttps
+    ? checkSsl(parsedUrl.hostname, Number(parsedUrl.port) || 443)
+    : Promise.resolve(null);
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 15000);
+  const start = Date.now();
+
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      signal: controller.signal,
+      redirect: "follow",
+    });
+
+    const body = await response.text();
+    const elapsed = Date.now() - start;
+
+    let bodyValid: boolean | null = null;
+    if (expected_body_contains) {
+      bodyValid = body.includes(expected_body_contains);
+    }
+
+    const isHealthy =
+      response.status === expected_status &&
+      (bodyValid === null || bodyValid === true);
+
+    const ssl = await sslPromise;
+
+    return {
+      url,
+      status: isHealthy ? "healthy" : "unhealthy",
+      http_status: response.status,
+      response_time_ms: elapsed,
+      ssl,
+      body_valid: bodyValid,
+      error: null,
+    };
+  } catch (err: unknown) {
+    const elapsed = Date.now() - start;
+    const ssl = await sslPromise;
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      url,
+      status: "error",
+      http_status: null,
+      response_time_ms: elapsed,
+      ssl,
+      body_valid: null,
+      error: message,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function apiHealth(
+  endpoints: HealthEndpoint[]
+): Promise<{ results: EndpointHealth[]; summary: { total: number; healthy: number; unhealthy: number; errors: number } }> {
+  if (!endpoints || endpoints.length === 0) {
+    throw new Error("Provide at least one endpoint to check");
+  }
+
+  const capped = endpoints.slice(0, 20);
+  const results = await Promise.all(capped.map(checkEndpoint));
+
+  const healthy = results.filter((r) => r.status === "healthy").length;
+  const unhealthy = results.filter((r) => r.status === "unhealthy").length;
+  const errors = results.filter((r) => r.status === "error").length;
+
+  return {
+    results,
+    summary: {
+      total: results.length,
+      healthy,
+      unhealthy,
+      errors,
+    },
+  };
+}