mcp-link-doctor 0.1.0

package/README.md

@@ -0,0 +1,71 @@
+# mcp-link-doctor
+
+An MCP server that analyzes websites for broken links, missing meta tags, and redirect chains. Returns a structured report with a health score and fix suggestions.
+
+## What it does
+
+- Checks all links on a page for 4xx/5xx errors (up to 20 links)
+- Detects missing meta tags: title, description, og:title, og:description, og:image, canonical, viewport
+- Traces redirect chains and flags excessive hops
+- Returns a score (0–100) and actionable suggestions
+
+## Install
+
+```bash
+npx mcp-link-doctor
+```
+
+## Configure in Claude Code
+
+Add to your `.claude/settings.json` (or `~/.claude/settings.json`):
+
+```json
+{
+  "mcpServers": {
+    "mcp-link-doctor": {
+      "command": "npx",
+      "args": ["mcp-link-doctor"],
+      "env": {
+        "MCPCAT_PROJECT_ID": "proj_your_id_here"
+      }
+    }
+  }
+}
+```
+
+Or if running locally from the built output:
+
+```json
+{
+  "mcpServers": {
+    "mcp-link-doctor": {
+      "command": "node",
+      "args": ["/path/to/mcp-link-doctor/dist/index.js"],
+      "env": {
+        "MCPCAT_PROJECT_ID": "proj_your_id_here"
+      }
+    }
+  }
+}
+```
+
+`MCPCAT_PROJECT_ID` is optional. Get your project ID from [mcpcat.io](https://mcpcat.io). The server runs fine without it — analytics are simply disabled.
+
+## Tool
+
+### `check-links`
+
+**Input:** `{ "url": "https://example.com" }`
+
+**Output:**
+```json
+{
+  "url": "https://example.com",
+  "brokenLinks": [{"href": "...", "status": 404, "text": "..."}],
+  "missingMetaTags": ["og:image", "canonical"],
+  "presentMetaTags": {"title": "...", "description": "..."},
+  "redirectChain": ["https://example.com -> https://www.example.com"],
+  "score": 85,
+  "suggestions": ["Add og:image meta tag", "Fix broken link (404): /old-page"]
+}
+```

package/dist/index.js

@@ -0,0 +1,217 @@
+#!/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 * as mcpcat from "mcpcat";
+const META_TAGS_TO_CHECK = [
+    "title",
+    "description",
+    "og:title",
+    "og:description",
+    "og:image",
+    "canonical",
+    "viewport",
+];
+async function followRedirects(url) {
+    const chain = [url];
+    let current = url;
+    for (let i = 0; i < 10; i++) {
+        let res;
+        try {
+            res = await fetch(current, {
+                method: "HEAD",
+                redirect: "manual",
+                signal: AbortSignal.timeout(5000),
+            });
+        }
+        catch {
+            break;
+        }
+        if (res.status >= 300 && res.status < 400) {
+            const location = res.headers.get("location");
+            if (!location)
+                break;
+            const next = location.startsWith("http") ? location : new URL(location, current).href;
+            chain.push(next);
+            current = next;
+        }
+        else {
+            break;
+        }
+    }
+    return { finalUrl: current, chain };
+}
+function extractLinks(html, baseUrl) {
+    const links = [];
+    const anchorRegex = /<a\s[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi;
+    let match;
+    while ((match = anchorRegex.exec(html)) !== null) {
+        const rawHref = match[1].trim();
+        const rawText = match[2].replace(/<[^>]+>/g, "").trim().slice(0, 100);
+        if (!rawHref || rawHref.startsWith("#") || rawHref.startsWith("mailto:") || rawHref.startsWith("javascript:")) {
+            continue;
+        }
+        try {
+            const href = rawHref.startsWith("http") ? rawHref : new URL(rawHref, baseUrl).href;
+            links.push({ href, text: rawText });
+        }
+        catch {
+            // skip malformed hrefs
+        }
+    }
+    return links;
+}
+function extractMetaTags(html) {
+    const found = {};
+    // title tag
+    const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    if (titleMatch) {
+        found["title"] = titleMatch[1].trim();
+    }
+    // <meta name="..." content="...">
+    const metaNameRegex = /<meta\s[^>]*name=["']([^"']+)["'][^>]*content=["']([^"']*)["'][^>]*>/gi;
+    let m;
+    while ((m = metaNameRegex.exec(html)) !== null) {
+        found[m[1].toLowerCase()] = m[2];
+    }
+    // also catch content before name
+    const metaNameRegex2 = /<meta\s[^>]*content=["']([^"']*)["'][^>]*name=["']([^"']+)["'][^>]*>/gi;
+    while ((m = metaNameRegex2.exec(html)) !== null) {
+        found[m[2].toLowerCase()] = m[1];
+    }
+    // <meta property="og:..." content="...">
+    const metaPropRegex = /<meta\s[^>]*property=["']([^"']+)["'][^>]*content=["']([^"']*)["'][^>]*>/gi;
+    while ((m = metaPropRegex.exec(html)) !== null) {
+        found[m[1].toLowerCase()] = m[2];
+    }
+    // reverse order too
+    const metaPropRegex2 = /<meta\s[^>]*content=["']([^"']*)["'][^>]*property=["']([^"']+)["'][^>]*>/gi;
+    while ((m = metaPropRegex2.exec(html)) !== null) {
+        found[m[2].toLowerCase()] = m[1];
+    }
+    // <link rel="canonical" href="...">
+    const canonicalMatch = html.match(/<link\s[^>]*rel=["']canonical["'][^>]*href=["']([^"']+)["'][^>]*>/i)
+        ?? html.match(/<link\s[^>]*href=["']([^"']+)["'][^>]*rel=["']canonical["'][^>]*>/i);
+    if (canonicalMatch) {
+        found["canonical"] = canonicalMatch[1];
+    }
+    return found;
+}
+async function checkLink(href) {
+    try {
+        const res = await fetch(href, {
+            method: "HEAD",
+            redirect: "follow",
+            signal: AbortSignal.timeout(6000),
+        });
+        return res.status;
+    }
+    catch {
+        return 0;
+    }
+}
+function computeScore(brokenLinks, missingMetaTags, redirectChainLength) {
+    let score = 100;
+    score -= brokenLinks.length * 10;
+    score -= missingMetaTags.length * 5;
+    if (redirectChainLength > 2)
+        score -= (redirectChainLength - 2) * 5;
+    return Math.max(0, score);
+}
+function buildSuggestions(brokenLinks, missingMetaTags, redirectChain) {
+    const suggestions = [];
+    for (const tag of missingMetaTags) {
+        suggestions.push(`Add ${tag} meta tag`);
+    }
+    for (const link of brokenLinks) {
+        suggestions.push(`Fix broken link (${link.status}): ${link.href}`);
+    }
+    if (redirectChain.length > 2) {
+        suggestions.push(`Reduce redirect chain (currently ${redirectChain.length - 1} hops): update links to point directly to ${redirectChain[redirectChain.length - 1]}`);
+    }
+    return suggestions;
+}
+async function analyzeUrl(url) {
+    // Follow redirects to get the final URL
+    const { finalUrl, chain } = await followRedirects(url);
+    // Fetch HTML
+    let html = "";
+    try {
+        const res = await fetch(finalUrl, {
+            signal: AbortSignal.timeout(10000),
+            headers: { "User-Agent": "mcp-link-doctor/0.1.0" },
+        });
+        html = await res.text();
+    }
+    catch (err) {
+        throw new Error(`Failed to fetch ${finalUrl}: ${String(err)}`);
+    }
+    // Extract and check links (limit to first 20)
+    const allLinks = extractLinks(html, finalUrl).slice(0, 20);
+    const brokenLinks = [];
+    await Promise.all(allLinks.map(async ({ href, text }) => {
+        const status = await checkLink(href);
+        if (status >= 400 || status === 0) {
+            brokenLinks.push({ href, status: status === 0 ? 0 : status, text });
+        }
+    }));
+    // Extract meta tags
+    const presentMetaTags = extractMetaTags(html);
+    const missingMetaTags = META_TAGS_TO_CHECK.filter((tag) => !presentMetaTags[tag]);
+    // Format redirect chain
+    const redirectChainFormatted = chain.length > 1
+        ? [chain.join(" -> ")]
+        : [];
+    const score = computeScore(brokenLinks, missingMetaTags, chain.length);
+    const suggestions = buildSuggestions(brokenLinks, missingMetaTags, chain);
+    return {
+        url,
+        brokenLinks,
+        missingMetaTags,
+        presentMetaTags,
+        redirectChain: redirectChainFormatted,
+        score,
+        suggestions,
+    };
+}
+const server = new McpServer({
+    name: "mcp-link-doctor",
+    version: "0.1.0",
+});
+// MCPcat analytics — replace MCPCAT_PROJECT_ID with your project ID from mcpcat.io
+const MCPCAT_PROJECT_ID = process.env["MCPCAT_PROJECT_ID"] ?? undefined;
+if (MCPCAT_PROJECT_ID)
+    mcpcat.track(server, MCPCAT_PROJECT_ID);
+server.tool("check-links", "Find broken links, missing meta tags, and redirect chains on any website. Returns a structured report with fix suggestions.", { url: z.string().describe("The URL of the website to analyze") }, async ({ url }) => {
+    let report;
+    try {
+        report = await analyzeUrl(url);
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ error: String(err) }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(report, null, 2),
+            },
+        ],
+    };
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Server failed to start:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "mcp-link-doctor",
+  "version": "0.1.0",
+  "description": "MCP server that finds broken links, missing meta tags, and redirect chains on any website. Returns a structured report with fix suggestions.",
+  "type": "module",
+  "bin": {
+    "mcp-link-doctor": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "keywords": ["mcp", "mcp-server", "broken-links", "seo", "link-checker", "meta-tags", "website-audit", "redirect-chain"],
+  "author": "Timothy Cai",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/linesatuni/agentic-waitlist.git",
+    "directory": "servers/mcp-link-doctor"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "mcpcat": "^0.1.15",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "typescript": "^6.0.2"
+  }
+}