mcp-web-reader 2.0.0

package/README.md

@@ -0,0 +1,255 @@
+# MCP Web Reader
+
+一个强大的 MCP (Model Context Protocol) 服务器，让 Claude 和其他大语言模型能够读取和解析网页内容。支持突破访问限制，轻松获取微信文章、时代杂志等受保护内容。
+
+## 功能特点
+
+- 🚀 **三引擎支持**：集成 Jina Reader API、本地解析器和 Playwright 浏览器
+- 🔄 **智能降级**：Jina Reader → 本地解析 → Playwright 浏览器三层自动切换
+- 🌐 **突破限制**：使用 Playwright 处理 Cloudflare、验证码等访问限制
+- 📦 **批量处理**：支持同时获取多个 URL
+- 🎯 **灵活控制**：可选择强制使用特定解析方式
+- 📝 **Markdown 输出**：自动转换为清晰的 Markdown 格式
+
+## 安装
+
+### 方法 1：从源码安装
+
+```bash
+# 克隆仓库
+git clone https://github.com/zacfire/mcp-web-reader.git
+cd mcp-web-reader
+
+# 安装依赖
+npm install
+
+# 构建项目
+npm run build
+
+# 安装 Playwright 浏览器（必需）
+npx playwright install chromium
+```
+
+### 方法 2：使用 npm 安装（推荐）
+
+发布后，您可以简单地通过 npm 安装：
+
+```bash
+npm install -g mcp-web-reader
+```
+
+**首次发布步骤**：
+如果这是第一次发布，请运行提供的发布脚本：
+
+```bash
+# 确保已登录 npm
+npm login
+
+# 运行发布脚本
+./publish.sh
+```
+
+## 配置
+
+### 快速配置
+
+在 Claude Desktop 的配置文件中添加：
+
+**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "web-reader": {
+      "command": "node",
+      "args": ["/absolute/path/to/mcp-web-reader/dist/index.js"]
+    }
+  }
+}
+```
+
+**重要**: 将 `/absolute/path/to/mcp-web-reader/dist/index.js` 替换为你的实际路径。
+
+### 详细配置指南
+
+📖 **完整的使用指南**：请查看 [USAGE_GUIDE.md](./USAGE_GUIDE.md)，包含：
+- **命令行使用（推荐）** - 适合使用 CLI 的用户
+- Claude Desktop 配置
+- Claude Code (Cursor) 配置
+- 其他 MCP 客户端配置
+- 使用示例和故障排除
+
+📖 **命令行专用指南**：请查看 [CLI_USAGE.md](./CLI_USAGE.md)，包含：
+- 使用 MCP Inspector 测试
+- 创建 CLI 包装器
+- 集成到自定义脚本
+- 命令行工具使用示例
+
+## 使用方法
+
+### 命令行使用（推荐）
+
+如果你主要使用命令行的 Claude，可以使用提供的 CLI 工具：
+
+```bash
+# 智能获取（自动降级）
+node cli.js fetch https://example.com
+
+# 强制使用 Jina Reader
+node cli.js jina https://example.com
+
+# 强制使用本地解析
+node cli.js local https://example.com
+
+# 强制使用浏览器模式（适用于微信文章等受限网站）
+node cli.js browser https://mp.weixin.qq.com/...
+```
+
+或者使用 MCP Inspector 进行交互式测试：
+
+```bash
+npx @modelcontextprotocol/inspector node dist/index.js
+```
+
+📖 详细说明请查看 [CLI_USAGE.md](./CLI_USAGE.md)
+
+### 在 Claude 中使用
+
+配置完成后，在 Claude 中可以使用以下命令：
+
+1.  **智能获取（推荐）**
+    * "请获取 [https://example.com](https://example.com) 的内容"
+    * 自动三层降级：Jina Reader → 本地解析 → Playwright 浏览器
+
+2.  **批量获取**
+    * "请获取这些网页：[url1, url2, url3]"
+    * 每个URL都享受智能降级策略
+
+3.  **强制使用 Jina Reader**
+    * "使用 Jina Reader 获取 [https://example.com](https://example.com)"
+
+4.  **强制使用本地解析**
+    * "使用本地解析器获取 [https://example.com](https://example.com)"
+
+5.  **强制使用浏览器模式**
+    * "使用浏览器获取 [https://example.com](https://example.com)"
+    * 直接跳过其他方式，适用于确定有访问限制的网站
+
+## 支持的受限网站类型
+
+✅ **微信公众号文章** - 自动绕过访问限制  
+✅ **时代杂志、纽约时报** - 突破付费墙和地区限制  
+✅ **Cloudflare 保护网站** - 通过真实浏览器绕过检测  
+✅ **需要 JavaScript 渲染的页面** - 完整执行页面脚本  
+✅ **有验证码/人机验证的网站** - 模拟真实用户行为
+
+## 工具列表
+
+-   `fetch_url` - 智能获取（三层降级：Jina → 本地 → Playwright）
+-   `fetch_url_with_jina` - 强制使用 Jina Reader
+-   `fetch_url_local` - 强制使用本地解析器  
+-   `fetch_url_with_browser` - 强制使用 Playwright 浏览器（突破访问限制）
+-   `fetch_multiple_urls` - 批量获取多个 URL
+
+## 技术架构
+
+### 智能降级策略
+```
+用户请求 URL
+    ↓
+1. Jina Reader API (最快，成功率高)
+    ↓ 失败
+2. 本地解析器 (Node.js + JSDOM)
+    ↓ 检测到访问限制
+3. Playwright 浏览器 (真实浏览器，突破限制)
+```
+
+### 访问限制检测
+自动识别以下情况并启用浏览器模式：
+- HTTP 状态码：403, 429, 503, 520-524
+- 错误关键词：Cloudflare, CAPTCHA, Access Denied, Rate Limit
+- 内容关键词：Security Check, Human Verification
+
+## 开发
+
+```bash
+# 开发模式（自动重新编译）
+npm run dev
+
+# 构建
+npm run build
+
+# 测试运行
+npm start
+
+# 安装浏览器二进制文件（首次使用必需）
+npx playwright install chromium
+```
+
+## 性能优化
+
+- ⚡ **浏览器实例复用** - 避免重复启动开销
+- 🚫 **资源过滤** - 阻止图片、样式表等不必要加载
+- 🎯 **智能选择** - 优先使用快速方法，必要时才用浏览器
+- 💾 **优雅关闭** - 正确清理浏览器资源
+
+## 验证安装
+
+### 测试 MCP 服务器
+
+1. **使用 MCP Inspector 测试**：
+```bash
+npx @modelcontextprotocol/inspector node dist/index.js
+```
+
+2. **测试工具功能**：
+在 Inspector 中输入以下 JSON 测试各种工具：
+```json
+{"method": "tools/call", "params": {"name": "fetch_url", "arguments": {"url": "https://example.com"}}}
+```
+
+### 在 Claude Desktop 中验证
+
+配置完成后，重启 Claude Desktop，然后在对话中输入：
+- "请获取 https://httpbin.org/json 的内容"
+
+如果能成功返回内容，说明安装成功。
+
+## 故障排除
+
+### 常见问题
+
+1. **"找不到模块" 错误**
+   - 确保已运行 `npm install`
+   - 确保已运行 `npm run build`
+
+2. **Claude Desktop 无法连接到 MCP 服务器**
+   - 检查配置文件路径是否正确
+   - 检查 `dist/index.js` 路径是否正确
+   - 重启 Claude Desktop
+
+3. **Playwright 浏览器相关错误**
+   - 确保已运行 `npx playwright install chromium`
+   - 检查系统是否支持图形界面（某些服务器环境可能需要额外配置）
+
+4. **微信文章无法获取**
+   - 微信文章需要 Playwright 浏览器模式
+   - 使用 `fetch_url_with_browser` 工具强制使用浏览器
+
+### 调试模式
+
+启用详细日志：
+```bash
+DEBUG=* node dist/index.js
+```
+
+## 贡献
+
+欢迎提交 Pull Request！
+
+## 许可证
+
+MIT License
+

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,598 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import fetch from "node-fetch";
+import { JSDOM } from "jsdom";
+import TurndownService from "turndown";
+import { chromium } from "playwright";
+// 创建服务器实例
+const server = new Server({
+    name: "web-reader",
+    version: "2.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// 初始化Turndown服务（将HTML转换为Markdown）
+const turndownService = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+});
+// 配置Turndown规则
+turndownService.addRule("skipScripts", {
+    filter: ["script", "style", "noscript"],
+    replacement: () => "",
+});
+// 浏览器实例管理
+let browser = null;
+// 获取或创建浏览器实例
+async function getBrowser() {
+    if (!browser) {
+        browser = await chromium.launch({
+            headless: true,
+            args: [
+                '--no-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-blink-features=AutomationControlled', // 禁用自动化检测
+                '--disable-infobars',
+                '--window-size=1920,1080',
+                '--start-maximized',
+            ],
+        });
+    }
+    return browser;
+}
+// 清理浏览器实例
+async function closeBrowser() {
+    if (browser) {
+        await browser.close();
+        browser = null;
+    }
+}
+// URL验证函数
+function isValidUrl(urlString) {
+    try {
+        const url = new URL(urlString);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+// 检测是否是微信文章链接
+function isWeixinUrl(url) {
+    return url.includes('mp.weixin.qq.com') || url.includes('weixin.qq.com');
+}
+// 检测是否需要使用浏览器模式
+function shouldUseBrowser(error, statusCode, content) {
+    const errorMessage = error.message.toLowerCase();
+    // 基于HTTP状态码判断
+    if (statusCode && [403, 429, 503, 520, 521, 522, 523, 524].includes(statusCode)) {
+        return true;
+    }
+    // 基于错误消息判断
+    const browserTriggers = [
+        'cloudflare',
+        'access denied',
+        'forbidden',
+        'captcha',
+        'rate limit',
+        'robot',
+        'security',
+        'blocked',
+        'protection',
+        'verification required',
+        '环境异常',
+        '验证'
+    ];
+    if (browserTriggers.some(trigger => errorMessage.includes(trigger))) {
+        return true;
+    }
+    // 基于响应内容判断
+    if (content) {
+        const contentLower = content.toLowerCase();
+        const contentTriggers = [
+            'cloudflare',
+            'ray id',
+            'access denied',
+            'security check',
+            'human verification',
+            'captcha',
+            // 微信特有的验证关键词
+            '环境异常',
+            '去验证',
+            '完成验证后即可继续访问',
+            'verify'
+        ];
+        if (contentTriggers.some(trigger => contentLower.includes(trigger))) {
+            return true;
+        }
+    }
+    return false;
+}
+// 使用Jina Reader获取内容
+async function fetchWithJinaReader(url) {
+    try {
+        // Jina Reader API URL
+        const jinaUrl = `https://r.jina.ai/${url}`;
+        // 创建超时控制器
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 30000);
+        const response = await fetch(jinaUrl, {
+            headers: {
+                "Accept": "text/markdown",
+                "User-Agent": "MCP-URLFetcher/2.0",
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            throw new Error(`Jina Reader API error! status: ${response.status}`);
+        }
+        const markdown = await response.text();
+        // 从Markdown中提取标题（通常是第一个#标题）
+        const titleMatch = markdown.match(/^#\s+(.+)$/m);
+        const title = titleMatch ? titleMatch[1] : "无标题";
+        return {
+            title,
+            content: markdown,
+            metadata: {
+                url,
+                fetchedAt: new Date().toISOString(),
+                contentLength: markdown.length,
+                method: "jina-reader",
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === 'AbortError') {
+                throw new Error(`Jina Reader请求超时（30秒）`);
+            }
+            throw new Error(`Jina Reader获取失败: ${error.message}`);
+        }
+        throw new Error(`Jina Reader获取失败: ${String(error)}`);
+    }
+}
+// 使用Playwright获取网页内容
+async function fetchWithPlaywright(url) {
+    let page = null;
+    const isWeixin = isWeixinUrl(url);
+    try {
+        const browserInstance = await getBrowser();
+        page = await browserInstance.newPage();
+        // 设置真实的 User-Agent（模拟 Chrome on Mac）
+        const userAgent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+        await page.setExtraHTTPHeaders({
+            'User-Agent': userAgent,
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+            'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'Cache-Control': 'no-cache',
+            'Pragma': 'no-cache',
+            ...(isWeixin ? { 'Referer': 'https://mp.weixin.qq.com/' } : {}),
+        });
+        await page.setViewportSize({ width: 1920, height: 1080 });
+        // 微信文章需要加载样式以正确渲染，其他网站可以过滤
+        if (!isWeixin) {
+            await page.route('**/*', (route) => {
+                const resourceType = route.request().resourceType();
+                if (['image', 'stylesheet', 'font', 'media'].includes(resourceType)) {
+                    route.abort();
+                }
+                else {
+                    route.continue();
+                }
+            });
+        }
+        // 导航到页面，设置更长的超时时间
+        await page.goto(url, {
+            timeout: 45000,
+            waitUntil: 'networkidle' // 等待网络空闲，确保 JS 完全执行
+        });
+        // 微信文章需要更长的等待时间
+        const waitTime = isWeixin ? 5000 : 2000;
+        await page.waitForTimeout(waitTime);
+        // 获取页面标题
+        const title = await page.title() || "无标题";
+        // 移除不需要的元素
+        await page.evaluate(() => {
+            const elementsToRemove = document.querySelectorAll('script, style, nav, header, footer, aside, .advertisement, .ads, .sidebar, .comments, .social-share');
+            elementsToRemove.forEach(el => el.remove());
+        });
+        // 获取主要内容（微信文章有特定的 DOM 结构）
+        const htmlContent = await page.evaluate(() => {
+            // 微信文章特定选择器
+            const weixinContent = document.querySelector('#js_content') ||
+                document.querySelector('.rich_media_content');
+            if (weixinContent) {
+                return weixinContent.innerHTML;
+            }
+            // 通用选择器
+            const mainContent = document.querySelector('main') ||
+                document.querySelector('article') ||
+                document.querySelector('[role="main"]') ||
+                document.querySelector('.content') ||
+                document.querySelector('#content') ||
+                document.querySelector('.post') ||
+                document.querySelector('.entry-content') ||
+                document.body;
+            return mainContent ? mainContent.innerHTML : document.body.innerHTML;
+        });
+        // 转换为Markdown
+        const markdown = turndownService.turndown(htmlContent);
+        // 清理内容
+        const cleanedContent = markdown
+            .replace(/\n{3,}/g, "\n\n")
+            .replace(/^\s+$/gm, "")
+            .trim();
+        return {
+            title,
+            content: cleanedContent,
+            metadata: {
+                url,
+                fetchedAt: new Date().toISOString(),
+                contentLength: cleanedContent.length,
+                method: "playwright-browser",
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Playwright获取失败: ${error.message}`);
+        }
+        throw new Error(`Playwright获取失败: ${String(error)}`);
+    }
+    finally {
+        if (page) {
+            await page.close();
+        }
+    }
+}
+// 本地提取网页内容的函数
+async function fetchWithLocalParser(url) {
+    try {
+        // 创建超时控制器
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 30000);
+        // 发送HTTP请求
+        const response = await fetch(url, {
+            headers: {
+                "User-Agent": "Mozilla/5.0 (compatible; MCP-URLFetcher/2.0)",
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        // 获取HTML内容
+        const html = await response.text();
+        // 使用JSDOM解析HTML
+        const dom = new JSDOM(html);
+        const document = dom.window.document;
+        // 获取标题
+        const title = document.querySelector("title")?.textContent || "无标题";
+        // 移除不需要的元素
+        const elementsToRemove = document.querySelectorAll("script, style, nav, header, footer, aside, .advertisement, .ads, .sidebar, .comments");
+        elementsToRemove.forEach(el => el.remove());
+        // 获取主要内容区域
+        const mainContent = document.querySelector("main") ||
+            document.querySelector("article") ||
+            document.querySelector('[role="main"]') ||
+            document.querySelector(".content") ||
+            document.querySelector("#content") ||
+            document.querySelector(".post") ||
+            document.querySelector(".entry-content") ||
+            document.body;
+        // 转换为Markdown
+        const markdown = turndownService.turndown(mainContent.innerHTML);
+        // 清理多余的空行和空格
+        const cleanedContent = markdown
+            .replace(/\n{3,}/g, "\n\n")
+            .replace(/^\s+$/gm, "")
+            .trim();
+        return {
+            title,
+            content: cleanedContent,
+            metadata: {
+                url,
+                fetchedAt: new Date().toISOString(),
+                contentLength: cleanedContent.length,
+                method: "local-parser",
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === 'AbortError') {
+                throw new Error(`本地解析请求超时（30秒）`);
+            }
+            throw new Error(`本地解析失败: ${error.message}`);
+        }
+        throw new Error(`本地解析失败: ${String(error)}`);
+    }
+}
+// 智能获取网页内容（三层降级策略：Jina → 本地 → Playwright）
+// 对于微信等已知需要浏览器的网站，直接使用浏览器模式
+async function fetchWebContent(url, preferJina = true) {
+    // 微信文章直接使用浏览器模式，因为其他方式无法绕过验证
+    if (isWeixinUrl(url)) {
+        console.error("检测到微信文章，直接使用Playwright浏览器模式");
+        return await fetchWithPlaywright(url);
+    }
+    if (preferJina) {
+        // 第一层：尝试Jina Reader
+        try {
+            return await fetchWithJinaReader(url);
+        }
+        catch (jinaError) {
+            console.error("Jina Reader失败，尝试本地解析:", jinaError instanceof Error ? jinaError.message : String(jinaError));
+            // 第二层：尝试本地解析
+            try {
+                return await fetchWithLocalParser(url);
+            }
+            catch (localError) {
+                console.error("本地解析失败，检查是否需要浏览器模式:", localError instanceof Error ? localError.message : String(localError));
+                // 判断是否需要使用浏览器模式
+                const jinaErr = jinaError instanceof Error ? jinaError : new Error(String(jinaError));
+                const localErr = localError instanceof Error ? localError : new Error(String(localError));
+                if (shouldUseBrowser(jinaErr) || shouldUseBrowser(localErr)) {
+                    console.error("检测到访问限制，使用Playwright浏览器模式");
+                    try {
+                        // 第三层：使用Playwright浏览器
+                        return await fetchWithPlaywright(url);
+                    }
+                    catch (browserError) {
+                        throw new Error(`所有方法都失败了。Jina: ${jinaErr.message}, 本地: ${localErr.message}, 浏览器: ${browserError instanceof Error ? browserError.message : String(browserError)}`);
+                    }
+                }
+                else {
+                    throw new Error(`Jina和本地解析都失败了。Jina: ${jinaErr.message}, 本地: ${localErr.message}`);
+                }
+            }
+        }
+    }
+    else {
+        // 如果不优先使用Jina，直接从本地解析开始
+        try {
+            return await fetchWithLocalParser(url);
+        }
+        catch (localError) {
+            const localErr = localError instanceof Error ? localError : new Error(String(localError));
+            if (shouldUseBrowser(localErr)) {
+                console.error("本地解析失败，检测到访问限制，使用Playwright浏览器模式");
+                return await fetchWithPlaywright(url);
+            }
+            else {
+                throw localErr;
+            }
+        }
+    }
+}
+// 处理工具列表请求
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "fetch_url",
+                description: "获取指定URL的网页内容，并转换为Markdown格式。默认使用Jina Reader，失败时自动切换到本地解析",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        url: {
+                            type: "string",
+                            description: "要获取内容的网页URL（必须是http或https协议）",
+                        },
+                        preferJina: {
+                            type: "boolean",
+                            description: "是否优先使用Jina Reader（默认为true）",
+                            default: true,
+                        },
+                    },
+                    required: ["url"],
+                },
+            },
+            {
+                name: "fetch_multiple_urls",
+                description: "批量获取多个URL的网页内容",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        urls: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                            },
+                            description: "要获取内容的网页URL列表",
+                            maxItems: 10, // 限制最多10个URL
+                        },
+                        preferJina: {
+                            type: "boolean",
+                            description: "是否优先使用Jina Reader（默认为true）",
+                            default: true,
+                        },
+                    },
+                    required: ["urls"],
+                },
+            },
+            {
+                name: "fetch_url_with_jina",
+                description: "强制使用Jina Reader获取网页内容（适用于复杂网页）",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        url: {
+                            type: "string",
+                            description: "要获取内容的网页URL",
+                        },
+                    },
+                    required: ["url"],
+                },
+            },
+            {
+                name: "fetch_url_local",
+                description: "强制使用本地解析器获取网页内容（适用于简单网页或Jina不可用时）",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        url: {
+                            type: "string",
+                            description: "要获取内容的网页URL",
+                        },
+                    },
+                    required: ["url"],
+                },
+            },
+            {
+                name: "fetch_url_with_browser",
+                description: "强制使用Playwright浏览器获取网页内容（适用于有访问限制的网站，如Cloudflare保护、验证码等）",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        url: {
+                            type: "string",
+                            description: "要获取内容的网页URL",
+                        },
+                    },
+                    required: ["url"],
+                },
+            },
+        ],
+    };
+});
+// 处理工具调用请求
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        if (name === "fetch_url") {
+            const { url, preferJina = true } = args;
+            // 验证URL
+            if (!isValidUrl(url)) {
+                throw new McpError(ErrorCode.InvalidParams, "无效的URL格式，请提供http或https协议的URL");
+            }
+            // 获取网页内容
+            const result = await fetchWebContent(url, preferJina);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**获取时间**: ${result.metadata.fetchedAt}\n**内容长度**: ${result.metadata.contentLength} 字符\n**解析方法**: ${result.metadata.method}\n\n---\n\n${result.content}`,
+                    },
+                ],
+            };
+        }
+        else if (name === "fetch_url_with_jina") {
+            const { url } = args;
+            if (!isValidUrl(url)) {
+                throw new McpError(ErrorCode.InvalidParams, "无效的URL格式");
+            }
+            const result = await fetchWithJinaReader(url);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**获取时间**: ${result.metadata.fetchedAt}\n**内容长度**: ${result.metadata.contentLength} 字符\n**解析方法**: Jina Reader\n\n---\n\n${result.content}`,
+                    },
+                ],
+            };
+        }
+        else if (name === "fetch_url_local") {
+            const { url } = args;
+            if (!isValidUrl(url)) {
+                throw new McpError(ErrorCode.InvalidParams, "无效的URL格式");
+            }
+            const result = await fetchWithLocalParser(url);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**获取时间**: ${result.metadata.fetchedAt}\n**内容长度**: ${result.metadata.contentLength} 字符\n**解析方法**: 本地解析器\n\n---\n\n${result.content}`,
+                    },
+                ],
+            };
+        }
+        else if (name === "fetch_multiple_urls") {
+            const { urls, preferJina = true } = args;
+            // 验证所有URL
+            const invalidUrls = urls.filter(url => !isValidUrl(url));
+            if (invalidUrls.length > 0) {
+                throw new McpError(ErrorCode.InvalidParams, `以下URL格式无效: ${invalidUrls.join(", ")}`);
+            }
+            // 并发获取所有URL内容
+            const results = await Promise.allSettled(urls.map(url => fetchWebContent(url, preferJina)));
+            // 整理结果
+            let combinedContent = "# 批量URL内容获取结果\n\n";
+            results.forEach((result, index) => {
+                const url = urls[index];
+                combinedContent += `## ${index + 1}. ${url}\n\n`;
+                if (result.status === "fulfilled") {
+                    const { title, content, metadata } = result.value;
+                    combinedContent += `**标题**: ${title}\n`;
+                    combinedContent += `**获取时间**: ${metadata.fetchedAt}\n`;
+                    combinedContent += `**内容长度**: ${metadata.contentLength} 字符\n`;
+                    combinedContent += `**解析方法**: ${metadata.method}\n\n`;
+                    combinedContent += `### 内容\n\n${content}\n\n`;
+                }
+                else {
+                    combinedContent += `**错误**: ${result.reason}\n\n`;
+                }
+                combinedContent += "---\n\n";
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: combinedContent,
+                    },
+                ],
+            };
+        }
+        else if (name === "fetch_url_with_browser") {
+            const { url } = args;
+            if (!isValidUrl(url)) {
+                throw new McpError(ErrorCode.InvalidParams, "无效的URL格式");
+            }
+            const result = await fetchWithPlaywright(url);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `# ${result.title}\n\n**URL**: ${result.metadata.url}\n**获取时间**: ${result.metadata.fetchedAt}\n**内容长度**: ${result.metadata.contentLength} 字符\n**解析方法**: Playwright浏览器\n\n---\n\n${result.content}`,
+                    },
+                ],
+            };
+        }
+        else {
+            throw new McpError(ErrorCode.MethodNotFound, `未知的工具: ${name}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            throw error;
+        }
+        throw new McpError(ErrorCode.InternalError, `工具执行失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+});
+// 启动服务器
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP Web Reader v2.0 已启动（支持Jina Reader + Playwright）");
+}
+// 优雅关闭处理
+process.on('SIGINT', async () => {
+    console.error("接收到SIGINT信号，正在关闭浏览器...");
+    await closeBrowser();
+    process.exit(0);
+});
+process.on('SIGTERM', async () => {
+    console.error("接收到SIGTERM信号，正在关闭浏览器...");
+    await closeBrowser();
+    process.exit(0);
+});
+main().catch((error) => {
+    console.error("服务器启动失败:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "mcp-web-reader",
+    "version": "2.0.0",
+    "description": "MCP server for reading web content with Jina Reader and local parser support",
+    "main": "dist/index.js",
+    "bin": {
+      "mcp-web-reader": "./dist/index.js"
+    },
+    "type": "module",
+    "scripts": {
+      "build": "tsc",
+      "start": "node dist/index.js",
+      "dev": "tsc --watch",
+      "claude-code": "node dist/index.js"
+    },
+    "repository": {
+      "type": "git",
+      "url": "git+https://github.com/Gracker/mcp-web-reader.git"
+    },
+    "bugs": {
+      "url": "https://github.com/Gracker/mcp-web-reader/issues"
+    },
+    "homepage": "https://github.com/Gracker/mcp-web-reader#readme",
+    "keywords": ["mcp", "claude", "web-scraping", "jina-reader"],
+    "author": "Gracker",
+    "license": "MIT",
+    "files": [
+      "dist",
+      "README.md",
+      "LICENSE"
+    ],
+    "dependencies": {
+      "@modelcontextprotocol/sdk": "^0.5.0",
+      "node-fetch": "^3.3.2",
+      "jsdom": "^24.0.0",
+      "turndown": "^7.1.3",
+      "playwright": "^1.40.0"
+    },
+    "devDependencies": {
+      "@types/node": "^20.0.0",
+      "@types/jsdom": "^21.1.6",
+      "@types/turndown": "^5.0.4",
+      "typescript": "^5.3.3"
+    }
+  }