web-fetcher-mcp 1.0.9 → 1.0.13

package/dist/index.js

@@ -8,6 +8,17 @@ import { focusInputElement } from './tools/focus-input.js';
 import { typeInputElement } from './tools/type-input.js';
 import { clickElement } from './tools/click-element.js';
 import { captureElement } from './tools/capture-element.js';
+import { getPageInfo } from './tools/get-page-info.js';
+import { openDevtools } from './tools/open-devtools.js';
+import { getConsoleLogs } from './tools/get-console-logs.js';
+import { scrollPage } from './tools/scroll-page.js';
+import { waitForElement } from './tools/wait-for-element.js';
+import { hoverElement } from './tools/hover-element.js';
+import { getElementAttributes } from './tools/get-element-attributes.js';
+import { selectOption } from './tools/select-option.js';
+import { navigateHistory } from './tools/navigate-history.js';
+import { uploadFile } from './tools/upload-file.js';
+import { executeJs } from './tools/execute-js.js';
 // 定义工具列表
 const tools = [
     {
@@ -46,11 +57,13 @@ const tools = [
     },
     {
         name: 'click-element',
-        description: '点击页面上的指定元素。支持按钮、链接、复选框等任意可点击元素。',
+        description: '点击页面上的指定元素。支持按钮、链接、复选框、树节点等任意可点击元素。支持多种选择器格式，兼容 React/Vue 等现代框架组件。',
         inputSchema: z.object({
             url: z.string().optional().default('current').describe('网页 URL，如果是 current 则使用当前已打开的页面'),
-            selector: z.string().describe('CSS 选择器，例如：#login-btn、.submit-button、button[type="submit"]'),
+            selector: z.string().describe('元素选择器，支持多种格式：\n1. CSS选择器：#login-btn、.submit-button、button[type="submit"]\n2. 文本匹配：text=登录（精确匹配文本）\n3. 包含文本：:has-text("登录")（包含指定文本）\n4. jQuery风格：:contains("登录")（包含指定文本）\n推荐使用 text=xxx 格式，兼容性最好'),
             useExistingPage: z.boolean().optional().default(true).describe('是否使用已存在的页面，默认 true'),
+            waitForNavigation: z.boolean().optional().default(false).describe('点击后是否等待页面导航完成，默认 false'),
+            timeout: z.number().optional().default(10000).describe('等待元素出现的超时时间（毫秒），默认 10000'),
         }),
     },
     {
@@ -63,6 +76,117 @@ const tools = [
             fullPage: z.boolean().optional().default(false).describe('是否截取整个页面（滚动截屏），仅在 selector 未提供时有效，默认 false'),
         }),
     },
+    {
+        name: 'get-page-info',
+        description: '获取当前页面的信息（HTML骨架、文本内容、表单元素等），不刷新页面。适合在点击导航后获取新页面内容。',
+        inputSchema: z.object({
+            url: z.string().optional().default('current').describe('网页 URL，如果是 current 则使用当前已打开的页面，默认 current'),
+            includeHtmlSkeleton: z.boolean().optional().default(false).describe('是否返回 HTML 骨架结构，默认 false'),
+            includeFormElements: z.boolean().optional().default(false).describe('是否返回页面表单元素信息，默认 false'),
+            includeText: z.boolean().optional().default(true).describe('是否返回页面文本内容，默认 true'),
+            contentSelector: z.string().optional().default('body').describe('内容选择器，用于指定要提取内容的 HTML 元素，默认 body'),
+            useExistingPage: z.boolean().optional().default(true).describe('是否使用已存在的页面（不刷新），默认 true'),
+            downloadImages: z.boolean().optional().default(false).describe('是否下载图片并转换为 base64，默认 false'),
+        }),
+    },
+    {
+        name: 'open-devtools',
+        description: '打开浏览器开发者工具（DevTools）。支持开启手机设备模拟模式，方便进行移动端页面调试。',
+        inputSchema: z.object({
+            url: z.string().optional().default('current').describe('网页 URL，如果是 current 则使用当前已打开的页面'),
+            isMobile: z.boolean().optional().default(false).describe('是否开启手机设备模式，默认 false'),
+            mobileDevice: z.string().optional().default('iPhone 13').describe('模拟的手机设备型号，如：iPhone 13、iPhone 14、Pixel 5、Galaxy S21 等，默认 iPhone 13。仅当 isMobile 为 true 时生效'),
+            useExistingPage: z.boolean().optional().default(true).describe('是否使用已存在的页面，默认 true'),
+        }),
+    },
+    {
+        name: 'get-console-logs',
+        description: '获取浏览器控制台日志，包括错误、警告、普通日志等。用于调试页面 JavaScript 错误和查看 console 输出。',
+        inputSchema: z.object({
+            url: z.string().optional().default('current').describe('网页 URL，如果是 current 则使用当前已打开的页面'),
+            logTypes: z.array(z.enum(['error', 'warn', 'log', 'info', 'debug', 'all'])).optional().default(['all']).describe('要获取的日志类型数组，默认 ["all"] 获取所有类型。可选值：error, warn, log, info, debug, all'),
+            clearAfterGet: z.boolean().optional().default(false).describe('获取后是否清空日志缓冲区，默认 false'),
+        }),
+    },
+    {
+        name: 'scroll-page',
+        description: '滚动页面到指定位置或元素。支持上下左右滚动、按像素量滚动、滚动到指定元素位置。',
+        inputSchema: z.object({
+            url: z.string().optional().default('current').describe('网页 URL，如果是 current 则使用当前已打开的页面'),
+            direction: z.enum(['up', 'down', 'left', 'right']).optional().default('down').describe('滚动方向：up(向上) / down(向下) / left(向左) / right(向右)，默认 down'),
+            amount: z.number().optional().default(500).describe('滚动的像素量，默认 500。当提供 selector 时此参数无效'),
+            selector: z.string().optional().describe('CSS 选择器，如果提供则滚动到该元素位置（忽略 direction 和 amount）'),
+            useExistingPage: z.boolean().optional().default(true).describe('是否使用已存在的页面，默认 true'),
+        }),
+    },
+    {
+        name: 'wait-for-element',
+        description: '等待指定元素出现在页面上。用于需要等待动态加载内容的场景，确保元素存在后再进行操作。',
+        inputSchema: z.object({
+            url: z.string().optional().default('current').describe('网页 URL，如果是 current 则使用当前已打开的页面'),
+            selector: z.string().describe('CSS 选择器，等待该选择器匹配的元素出现'),
+            timeout: z.number().optional().default(30000).describe('超时时间（毫秒），默认 30000'),
+            state: z.enum(['attached', 'visible', 'hidden']).optional().default('visible').describe('等待状态：attached - 元素存在于DOM中；visible - 元素可见（默认）；hidden - 元素隐藏或不存在'),
+            useExistingPage: z.boolean().optional().default(true).describe('是否使用已存在的页面，默认 true'),
+        }),
+    },
+    {
+        name: 'hover-element',
+        description: '将鼠标悬停在指定元素上。用于触发悬停菜单、工具提示等需要鼠标悬停才能显示的交互效果。',
+        inputSchema: z.object({
+            url: z.string().optional().default('current').describe('网页 URL，如果是 current 则使用当前已打开的页面'),
+            selector: z.string().describe('CSS 选择器，悬停到该元素上'),
+            useExistingPage: z.boolean().optional().default(true).describe('是否使用已存在的页面，默认 true'),
+        }),
+    },
+    {
+        name: 'get-element-attributes',
+        description: '获取页面元素的属性值。可以获取指定属性，也可以获取元素的所有属性。用于检查元素状态、获取数据属性等。',
+        inputSchema: z.object({
+            url: z.string().optional().default('current').describe('网页 URL，如果是 current 则使用当前已打开的页面'),
+            selector: z.string().describe('CSS 选择器'),
+            attributes: z.array(z.string()).optional().default([]).describe('要获取的属性名列表，为空则获取所有属性。例如：["href", "data-id", "class"]'),
+            useExistingPage: z.boolean().optional().default(true).describe('是否使用已存在的页面，默认 true'),
+        }),
+    },
+    {
+        name: 'select-option',
+        description: '选择下拉菜单的选项。支持原生 select 元素和常见 UI 框架的自定义下拉菜单（Element UI、Ant Design 等）。可通过 value、显示文本或索引选择。',
+        inputSchema: z.object({
+            url: z.string().optional().default('current').describe('网页 URL，如果是 current 则使用当前已打开的页面'),
+            selector: z.string().describe('CSS 选择器，指向 select 元素或自定义下拉菜单触发元素'),
+            value: z.string().optional().describe('按 option 的 value 属性选择'),
+            label: z.string().optional().describe('按 option 的显示文本选择'),
+            index: z.number().optional().describe('按索引选择（从 0 开始）'),
+            useExistingPage: z.boolean().optional().default(true).describe('是否使用已存在的页面，默认 true'),
+        }),
+    },
+    {
+        name: 'navigate-history',
+        description: '浏览器前进或后退导航。用于在浏览历史中前进或后退，等效于浏览器的后退/前进按钮。',
+        inputSchema: z.object({
+            direction: z.enum(['back', 'forward']).optional().default('back').describe('导航方向：back(后退) / forward(前进)，默认 back'),
+        }),
+    },
+    {
+        name: 'upload-file',
+        description: '上传文件到页面上的文件输入框。支持 input[type="file"] 元素，自动处理隐藏的文件输入控件。',
+        inputSchema: z.object({
+            url: z.string().optional().default('current').describe('网页 URL，如果是 current 则使用当前已打开的页面'),
+            selector: z.string().describe('CSS 选择器，指向 input[type="file"] 元素'),
+            filePath: z.string().describe('要上传的文件的绝对路径'),
+            useExistingPage: z.boolean().optional().default(true).describe('是否使用已存在的页面，默认 true'),
+        }),
+    },
+    {
+        name: 'execute-js',
+        description: '在页面中执行任意 JavaScript 代码并返回结果。可以用于执行复杂的 DOM 操作、获取数据、调用页面上的函数等。例如：document.getElementById("btn").click()、document.querySelector(".title").textContent、window.scrollTo(0, document.body.scrollHeight)',
+        inputSchema: z.object({
+            url: z.string().optional().default('current').describe('网页 URL，如果是 current 则使用当前已打开的页面'),
+            script: z.string().describe('要执行的 JavaScript 代码。支持完整的 JS 语法，可以访问 DOM 和页面上的全局变量。返回值会被序列化输出'),
+            useExistingPage: z.boolean().optional().default(true).describe('是否使用已存在的页面，默认 true'),
+        }),
+    },
 ];
 // 创建 MCP Server
 const server = new Server({
@@ -229,7 +353,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     if (name === 'click-element') {
         const validatedArgs = tools[3].inputSchema.parse(args);
         console.error(`正在点击元素: ${validatedArgs.selector}`);
-        const result = await clickElement(validatedArgs.url, validatedArgs.selector, validatedArgs.useExistingPage !== false);
+        const result = await clickElement(validatedArgs.url, validatedArgs.selector, validatedArgs.useExistingPage !== false, validatedArgs.waitForNavigation || false, validatedArgs.timeout || 10000);
         if (result.success) {
             const info = result.elementInfo;
             let responseText = `✅ 点击成功！\n\n`;
@@ -302,6 +426,429 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
         }
     }
+    if (name === 'get-page-info') {
+        const validatedArgs = tools[5].inputSchema.parse(args);
+        console.error(`正在获取页面信息（不刷新）: ${validatedArgs.url}`);
+        const result = await getPageInfo(validatedArgs.url, validatedArgs.includeHtmlSkeleton || false, validatedArgs.includeFormElements || false, validatedArgs.includeText !== false, validatedArgs.contentSelector || 'body', validatedArgs.useExistingPage !== false, validatedArgs.downloadImages || false);
+        if (result.success) {
+            const contentParts = [];
+            // 添加页面基本信息
+            contentParts.push({
+                type: 'text',
+                text: `📄 页面信息\n- 标题: ${result.title}\n- URL: ${result.url}\n`,
+            });
+            // 添加 HTML 骨架
+            if (validatedArgs.includeHtmlSkeleton && result.htmlSkeleton) {
+                contentParts.push({
+                    type: 'text',
+                    text: `\n🦴 HTML 骨架:\n\`\`\`html\n${result.htmlSkeleton}\n\`\`\`\n`,
+                });
+            }
+            // 添加表单元素
+            if (validatedArgs.includeFormElements && result.formElements && result.formElements.length > 0) {
+                contentParts.push({
+                    type: 'text',
+                    text: `\n📋 页面表单元素 (${result.formElements.length} 个):\n`,
+                });
+                result.formElements.forEach((el, i) => {
+                    let elInfo = `${i + 1}. <${el.tagName}`;
+                    if (el.type)
+                        elInfo += ` type="${el.type}"`;
+                    if (el.id)
+                        elInfo += ` id="${el.id}"`;
+                    if (el.name)
+                        elInfo += ` name="${el.name}"`;
+                    if (el.placeholder)
+                        elInfo += ` placeholder="${el.placeholder.slice(0, 30)}"`;
+                    if (el.value)
+                        elInfo += ` value="${el.value.slice(0, 30)}"`;
+                    elInfo += `>\n   选择器: ${el.selector}\n`;
+                    contentParts.push({
+                        type: 'text',
+                        text: elInfo,
+                    });
+                });
+            }
+            // 添加文本内容
+            if (validatedArgs.includeText !== false && result.text) {
+                contentParts.push({
+                    type: 'text',
+                    text: `\n📝 页面文本内容:\n${result.text}`,
+                });
+            }
+            // 添加下载的图片（如果启用）
+            if (validatedArgs.downloadImages && result.downloadedImages && result.downloadedImages.length > 0) {
+                contentParts.push({
+                    type: 'text',
+                    text: `\n🖼️ 已下载图片 (${result.downloadedImages.length} 张):`,
+                });
+                for (const img of result.downloadedImages) {
+                    contentParts.push({
+                        type: 'image',
+                        data: img.base64,
+                        mimeType: img.mimeType,
+                    });
+                }
+            }
+            // 否则只添加图片 URL 列表
+            else if (result.images && result.images.length > 0) {
+                contentParts.push({
+                    type: 'text',
+                    text: `\n🖼️ 页面图片 URL (${result.images.length} 个):\n${result.images.map((url, i) => `${i + 1}. ${url}`).join('\n')}`,
+                });
+            }
+            return { content: contentParts };
+        }
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `获取页面信息失败：${result.error || '未知错误'}`,
+                    }],
+            };
+        }
+    }
+    if (name === 'open-devtools') {
+        const validatedArgs = tools[6].inputSchema.parse(args);
+        console.error(`正在打开开发者工具: ${validatedArgs.isMobile ? `手机模式 (${validatedArgs.mobileDevice})` : '桌面模式'}`);
+        const result = await openDevtools(validatedArgs.url, validatedArgs.isMobile || false, validatedArgs.mobileDevice || 'iPhone 13', validatedArgs.useExistingPage !== false);
+        if (result.success) {
+            let responseText = `✅ 开发者工具已打开！\n\n`;
+            responseText += `当前状态:\n`;
+            responseText += `- 页面 URL: ${result.url}\n`;
+            responseText += `- 设备模式: ${validatedArgs.isMobile ? `📱 手机模式 (${validatedArgs.mobileDevice})` : '🖥️ 桌面模式'}\n`;
+            if (validatedArgs.isMobile && result.viewport) {
+                responseText += `- 视口尺寸: ${result.viewport.width} × ${result.viewport.height}\n`;
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: responseText,
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 打开开发者工具失败：${result.error || '未知错误'}`,
+                    }],
+            };
+        }
+    }
+    if (name === 'get-console-logs') {
+        const validatedArgs = tools[7].inputSchema.parse(args);
+        console.error(`正在获取控制台日志: ${validatedArgs.logTypes?.join(', ') || 'all'}`);
+        const result = await getConsoleLogs(validatedArgs.url, validatedArgs.logTypes || ['all'], validatedArgs.clearAfterGet || false);
+        if (result.success) {
+            let responseText = `📋 控制台日志\n\n`;
+            responseText += `页面: ${result.url}\n`;
+            responseText += `总日志数: ${result.totalCount}\n`;
+            responseText += `- 🔴 错误: ${result.errorCount}\n`;
+            responseText += `- 🟡 警告: ${result.warnCount}\n`;
+            responseText += `- 🔵 其他: ${result.totalCount - result.errorCount - result.warnCount}\n\n`;
+            if (result.logs.length > 0) {
+                responseText += `---\n\n`;
+                result.logs.forEach((log, i) => {
+                    const icon = log.type === 'error' ? '🔴' : log.type === 'warn' ? '🟡' : '🔵';
+                    responseText += `${icon} [${log.type.toUpperCase()}] ${log.message}\n`;
+                    if (log.location) {
+                        responseText += `   📍 ${log.location}\n`;
+                    }
+                    if (log.stack) {
+                        responseText += `   📚 堆栈:\n${log.stack.split('\n').map(line => `      ${line}`).join('\n')}\n`;
+                    }
+                    responseText += `\n`;
+                });
+            }
+            else {
+                responseText += `暂无日志\n`;
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: responseText,
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 获取控制台日志失败：${result.error || '未知错误'}`,
+                    }],
+            };
+        }
+    }
+    if (name === 'scroll-page') {
+        const validatedArgs = tools[8].inputSchema.parse(args);
+        console.error(`正在滚动页面: ${validatedArgs.selector ? `到元素 ${validatedArgs.selector}` : `${validatedArgs.direction || 'down'} ${validatedArgs.amount || 500}px`}`);
+        const result = await scrollPage(validatedArgs.url, validatedArgs.direction || 'down', validatedArgs.amount || 500, validatedArgs.selector, validatedArgs.useExistingPage !== false);
+        if (result.success) {
+            let responseText = `✅ 滚动成功！\n\n`;
+            responseText += `滚动信息:\n`;
+            responseText += `- 当前位置: x=${result.scrollPosition.x}, y=${result.scrollPosition.y}\n`;
+            responseText += `- 页面高度: ${result.pageHeight}px\n`;
+            responseText += `- 视口高度: ${result.viewportHeight}px\n`;
+            const scrollPercentage = result.pageHeight > 0
+                ? Math.round((result.scrollPosition.y / (result.pageHeight - result.viewportHeight)) * 100)
+                : 0;
+            responseText += `- 滚动进度: ~${scrollPercentage}%\n`;
+            return {
+                content: [{
+                        type: 'text',
+                        text: responseText,
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 滚动失败：${result.error || '未知错误'}`,
+                    }],
+            };
+        }
+    }
+    if (name === 'wait-for-element') {
+        const validatedArgs = tools[9].inputSchema.parse(args);
+        console.error(`等待元素: ${validatedArgs.selector} (状态: ${validatedArgs.state || 'visible'}, 超时: ${validatedArgs.timeout || 30000}ms)`);
+        const result = await waitForElement(validatedArgs.url, validatedArgs.selector, validatedArgs.timeout || 30000, validatedArgs.state || 'visible', validatedArgs.useExistingPage !== false);
+        if (result.success) {
+            const info = result.elementInfo;
+            let responseText = `✅ 元素已${validatedArgs.state === 'hidden' ? '隐藏' : '出现'}！\n\n`;
+            if (info) {
+                responseText += `元素信息:\n`;
+                responseText += `- 标签: ${info.tagName}\n`;
+                if (info.type)
+                    responseText += `- 类型: ${info.type}\n`;
+                if (info.id)
+                    responseText += `- ID: ${info.id}\n`;
+                if (info.name)
+                    responseText += `- Name: ${info.name}\n`;
+                if (info.text)
+                    responseText += `- 文本: ${info.text.slice(0, 100)}\n`;
+                responseText += `- 可见: ${info.visible ? '是' : '否'}\n`;
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: responseText,
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 等待元素失败：${result.error || '未知错误'}`,
+                    }],
+            };
+        }
+    }
+    if (name === 'hover-element') {
+        const validatedArgs = tools[10].inputSchema.parse(args);
+        console.error(`正在悬停到元素: ${validatedArgs.selector}`);
+        const result = await hoverElement(validatedArgs.url, validatedArgs.selector, validatedArgs.useExistingPage !== false);
+        if (result.success) {
+            const info = result.elementInfo;
+            let responseText = `✅ 悬停成功！\n\n`;
+            responseText += `元素信息:\n`;
+            responseText += `- 标签: ${info?.tagName}\n`;
+            if (info?.id)
+                responseText += `- ID: ${info.id}\n`;
+            if (info?.className)
+                responseText += `- Class: ${info.className}\n`;
+            if (info?.text)
+                responseText += `- 文本: ${info.text.slice(0, 100)}\n`;
+            return {
+                content: [{
+                        type: 'text',
+                        text: responseText,
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 悬停失败：${result.error || '未知错误'}`,
+                    }],
+            };
+        }
+    }
+    if (name === 'get-element-attributes') {
+        const validatedArgs = tools[11].inputSchema.parse(args);
+        console.error(`获取元素属性: ${validatedArgs.selector}`);
+        const result = await getElementAttributes(validatedArgs.url, validatedArgs.selector, validatedArgs.attributes || [], validatedArgs.useExistingPage !== false);
+        if (result.success) {
+            let responseText = `✅ 获取属性成功！\n\n`;
+            if (result.elementInfo) {
+                responseText += `元素信息:\n`;
+                responseText += `- 标签: ${result.elementInfo.tagName}\n`;
+                if (result.elementInfo.id)
+                    responseText += `- ID: ${result.elementInfo.id}\n`;
+                if (result.elementInfo.className)
+                    responseText += `- Class: ${result.elementInfo.className}\n`;
+                responseText += `\n`;
+            }
+            responseText += `属性列表 (${Object.keys(result.attributes).length} 个):\n`;
+            for (const [key, value] of Object.entries(result.attributes)) {
+                const displayValue = value.length > 100 ? value.slice(0, 100) + '...' : value;
+                responseText += `- ${key}: ${displayValue}\n`;
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: responseText,
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 获取属性失败：${result.error || '未知错误'}`,
+                    }],
+            };
+        }
+    }
+    if (name === 'select-option') {
+        const validatedArgs = tools[12].inputSchema.parse(args);
+        console.error(`选择下拉选项: ${validatedArgs.selector}`);
+        const result = await selectOption(validatedArgs.url, validatedArgs.selector, validatedArgs.value, validatedArgs.label, validatedArgs.index, validatedArgs.useExistingPage !== false);
+        if (result.success) {
+            let responseText = `✅ 选择成功！\n\n`;
+            responseText += `选中项:\n`;
+            if (result.selectedValue)
+                responseText += `- Value: ${result.selectedValue}\n`;
+            if (result.selectedText)
+                responseText += `- 文本: ${result.selectedText}\n`;
+            if (result.allOptions && result.allOptions.length > 0) {
+                responseText += `\n所有选项 (${result.allOptions.length} 个):\n`;
+                result.allOptions.forEach((opt, i) => {
+                    const marker = opt.selected ? ' ← 已选中' : '';
+                    responseText += `${i}. ${opt.text} (value="${opt.value}")${marker}\n`;
+                });
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: responseText,
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 选择失败：${result.error || '未知错误'}`,
+                    }],
+            };
+        }
+    }
+    if (name === 'navigate-history') {
+        const validatedArgs = tools[13].inputSchema.parse(args);
+        console.error(`导航历史: ${validatedArgs.direction === 'back' ? '后退' : '前进'}`);
+        const result = await navigateHistory(validatedArgs.direction);
+        if (result.success) {
+            let responseText = `✅ 导航成功！\n\n`;
+            responseText += `方向: ${result.direction === 'back' ? '⬅️ 后退' : '➡️ 前进'}\n`;
+            responseText += `页面标题: ${result.title}\n`;
+            responseText += `页面 URL: ${result.url}\n`;
+            return {
+                content: [{
+                        type: 'text',
+                        text: responseText,
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 导航失败：${result.error || '未知错误'}`,
+                    }],
+            };
+        }
+    }
+    if (name === 'upload-file') {
+        const validatedArgs = tools[14].inputSchema.parse(args);
+        console.error(`上传文件: ${validatedArgs.filePath} -> ${validatedArgs.selector}`);
+        const result = await uploadFile(validatedArgs.url, validatedArgs.selector, validatedArgs.filePath, validatedArgs.useExistingPage !== false);
+        if (result.success) {
+            let responseText = `✅ 文件上传成功！\n\n`;
+            responseText += `文件路径: ${result.filePath}\n`;
+            if (result.elementInfo) {
+                responseText += `\n上传控件信息:\n`;
+                responseText += `- 标签: ${result.elementInfo.tagName}\n`;
+                if (result.elementInfo.name)
+                    responseText += `- Name: ${result.elementInfo.name}\n`;
+                if (result.elementInfo.id)
+                    responseText += `- ID: ${result.elementInfo.id}\n`;
+                if (result.elementInfo.accept)
+                    responseText += `- 接受的文件类型: ${result.elementInfo.accept}\n`;
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: responseText,
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 文件上传失败：${result.error || '未知错误'}`,
+                    }],
+            };
+        }
+    }
+    if (name === 'execute-js') {
+        const validatedArgs = tools[15].inputSchema.parse(args);
+        console.error(`执行 JavaScript 代码: ${validatedArgs.script.slice(0, 100)}...`);
+        const result = await executeJs(validatedArgs.url, validatedArgs.script, validatedArgs.useExistingPage !== false);
+        if (result.success) {
+            let responseText = `✅ 执行成功！\n\n`;
+            responseText += `返回类型: ${result.resultType}\n`;
+            if (result.result !== undefined && result.result !== null) {
+                responseText += `\n📦 返回结果:\n`;
+                if (typeof result.result === 'object') {
+                    responseText += `\`\`\`json\n${JSON.stringify(result.result, null, 2)}\n\`\`\`\n`;
+                }
+                else {
+                    responseText += `${result.result}\n`;
+                }
+            }
+            else if (result.result === null) {
+                responseText += `\n📦 返回结果: null\n`;
+            }
+            else {
+                responseText += `\n📦 返回结果: undefined（无返回值）\n`;
+            }
+            if (result.consoleOutput && result.consoleOutput.length > 0) {
+                responseText += `\n📋 控制台输出:\n`;
+                result.consoleOutput.forEach((line) => {
+                    responseText += `${line}\n`;
+                });
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: responseText,
+                    }],
+            };
+        }
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 执行失败：${result.error || '未知错误'}`,
+                    }],
+            };
+        }
+    }
     throw new Error(`未知工具：${name}`);
 });
 // 启动服务器