@mearl/mcp-server 2.0.0

package/dist/index.js

@@ -0,0 +1,1837 @@
+#!/usr/bin/env node
+/**
+ * Mearl MCP Server
+ *
+ * 提供 MCP 工具让 AI 能够与浏览器交互:
+ * - browser_get_requests: 获取历史请求
+ * - browser_get_events: 获取 RUM/aplus 埋点事件
+ * - browser_get_logs: 获取控制台日志
+ * - browser_set_mock: 设置 Mock 数据
+ *
+ * 命令行参数:
+ * - configure / --configure: 运行配置向导
+ * - uninstall / --uninstall: 卸载并清理配置
+ * - --extension-id=ID: 指定 Chrome Extension ID
+ */
+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 * as client from '@mearl/client';
+import { writeFileSync, appendFileSync, readFileSync, existsSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, dirname } from 'path';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { RESPONSE_SIZE_SMALL, RESPONSE_SIZE_MEDIUM, RESPONSE_SIZE_LARGE, RESPONSE_SIZE_MAX, } from './constants.js';
+// 日志输出到 stderr（不影响 stdio 通信）
+const LOG_FILE = join(tmpdir(), 'mearl-mcp-server.log');
+const log = (...args) => {
+    const msg = `[${new Date().toISOString()}] [MCP Server] ${args.join(' ')}\n`;
+    try {
+        appendFileSync(LOG_FILE, msg);
+    }
+    catch {
+        // Ignore
+    }
+    console.error('[MCP Server]', ...args);
+};
+// 解析命令行参数
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let extensionId;
+    let uninstall = false;
+    let configure = false;
+    for (const arg of args) {
+        if (arg.startsWith('--extension-id=')) {
+            extensionId = arg.split('=')[1];
+        }
+        else if (arg.startsWith('--id=')) {
+            extensionId = arg.split('=')[1];
+        }
+        else if (arg === '--uninstall' || arg === 'uninstall') {
+            uninstall = true;
+        }
+        else if (arg === '--configure' || arg === 'configure') {
+            configure = true;
+        }
+    }
+    return { extensionId, uninstall, configure };
+}
+/**
+ * 分析响应数据，提供统计信息
+ */
+function analyzeResponseData(result) {
+    const stats = {};
+    try {
+        if (result && typeof result === 'object' && result.meta) {
+            stats.meta = result.meta;
+            // 分析实际数据数组
+            const dataArray = result.requests || result.logs;
+            if (Array.isArray(dataArray) && dataArray.length > 0) {
+                const sample = dataArray[0];
+                const fieldSizes = [];
+                for (const [key, value] of Object.entries(sample)) {
+                    if (value !== null && value !== undefined) {
+                        const size = JSON.stringify(value).length;
+                        fieldSizes.push({ path: key, size });
+                    }
+                }
+                // 按大小排序，取前 3 个
+                fieldSizes.sort((a, b) => b.size - a.size);
+                stats.largestFields = fieldSizes.slice(0, 3);
+            }
+        }
+    }
+    catch {
+        // 忽略分析错误
+    }
+    return stats;
+}
+/**
+ * 根据工具名称和参数生成优化建议
+ */
+function getOptimizationSuggestions(toolName, args, result, stats) {
+    const suggestions = [];
+    if (toolName === 'browser_get_requests') {
+        const count = args.count || 10;
+        const hasFields = args.fields && args.fields.length > 0;
+        const includeBody = args.includeBody !== false;
+        const keysOnly = args.keysOnly === true;
+        // 最优先建议：使用字段提取
+        if (!keysOnly && !hasFields && includeBody) {
+            suggestions.push('Use "keysOnly: true" to preview data structure first');
+            suggestions.push('Use "fields: [...]" to extract only needed fields');
+            // 基于实际数据推荐字段
+            if (stats.largestFields && stats.largestFields.length > 0) {
+                const fieldNames = stats.largestFields
+                    .filter(f => !['responseBody', 'postData'].includes(f.path))
+                    .map(f => f.path);
+                if (fieldNames.length > 0) {
+                    suggestions.push(`Example: { fields: ["${fieldNames[0]}", "apiName", "status"] }`);
+                }
+            }
+        }
+        // Body 相关建议
+        if (includeBody) {
+            const hasLargeBody = stats.largestFields?.some(f => ['responseBody', 'postData'].includes(f.path) && f.size > 10000);
+            if (hasLargeBody) {
+                suggestions.push('Response/request bodies are large - consider setting "includeBody: false"');
+                suggestions.push(`Or reduce "maxBodySize" (current: ${args.maxBodySize || 50000} bytes)`);
+            }
+        }
+        // 数量建议
+        if (count > 10) {
+            suggestions.push(`Reduce "count" from ${count} to fewer requests`);
+        }
+        // 过滤建议
+        if (!args.filter) {
+            suggestions.push('Add "filter" regex to match specific APIs (e.g., ".*\\.cart\\..*")');
+        }
+        // Headers 建议
+        if (args.includeHeaders) {
+            suggestions.push('Set "includeHeaders: false" to omit headers (often not needed)');
+        }
+    }
+    if (toolName === 'browser_get_logs') {
+        const limit = args.limit || 100;
+        if (limit > 50) {
+            suggestions.push(`Reduce "limit" from ${limit} to fewer logs`);
+        }
+        if (!args.filter) {
+            suggestions.push('Add "filter" to match specific log patterns');
+        }
+        if (!args.level || args.level === 'all') {
+            suggestions.push('Filter by specific "level" (error/warn/info/log)');
+        }
+    }
+    return suggestions;
+}
+/**
+ * 智能格式化响应，根据大小决定格式化策略和是否添加提示
+ */
+function formatResponseWithSizeCheck(result, toolName, args) {
+    // 先序列化为压缩格式测量大小
+    const compactStr = JSON.stringify(result);
+    const compactSize = Buffer.byteLength(compactStr, 'utf-8');
+    // 预估格式化后的大小（约 1.7 倍）
+    const estimatedFormattedSize = compactSize * 1.7;
+    const sizeKB = Math.round(compactSize / 1024);
+    const formattedSizeKB = Math.round(estimatedFormattedSize / 1024);
+    // 分析数据特征
+    const stats = analyzeResponseData(result);
+    // 策略 1: 小响应（<50KB 压缩）- 直接格式化输出，无需前置说明
+    // meta 信息已经在 JSON 中，AI 可以直接读取
+    if (compactSize < RESPONSE_SIZE_SMALL) {
+        return [
+            {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            },
+        ];
+    }
+    // 策略 2: 中等响应（50-200KB 压缩）- 格式化 + 简要提示
+    if (compactSize < RESPONSE_SIZE_MEDIUM) {
+        const suggestions = getOptimizationSuggestions(toolName, args, result, stats);
+        let header = `💡 Response size: ${formattedSizeKB}KB (formatted)`;
+        if (suggestions.length > 0) {
+            header += `\n\nOptimization suggestions:`;
+            header += suggestions.map((s, i) => `\n  ${i + 1}. ${s}`).join('');
+        }
+        return [
+            {
+                type: 'text',
+                text: `${header}\n\n${'─'.repeat(60)}\n\n${JSON.stringify(result, null, 2)}`,
+            },
+        ];
+    }
+    // 策略 3: 大响应（200-500KB 压缩）- 压缩格式 + 优化提示
+    if (compactSize < RESPONSE_SIZE_LARGE) {
+        const suggestions = getOptimizationSuggestions(toolName, args, result, stats);
+        let header = `⚠️ Large response: ${sizeKB}KB (compact format to save space)\n`;
+        header += `Formatted size would be ~${formattedSizeKB}KB\n`;
+        // 如果有 meta，提取关键信息到头部
+        if (stats.meta) {
+            header += `\n📊 Data: ${stats.meta.count} items returned`;
+            if (stats.meta.totalMatched > stats.meta.count) {
+                header += ` (${stats.meta.totalMatched} matched, ${stats.meta.totalInBuffer} in buffer)`;
+            }
+        }
+        if (stats.largestFields && stats.largestFields.length > 0) {
+            header += `\nLargest fields per item:`;
+            stats.largestFields.forEach(f => {
+                header += `\n  • ${f.path}: ~${Math.round(f.size / 1024)}KB`;
+            });
+        }
+        if (suggestions.length > 0) {
+            header += `\n\n🎯 Optimization suggestions:`;
+            header += suggestions.map((s, i) => `\n  ${i + 1}. ${s}`).join('');
+        }
+        return [
+            {
+                type: 'text',
+                text: `${header}\n\n${'─'.repeat(60)}\n\n${compactStr}`,
+            },
+        ];
+    }
+    // 策略 4: 超大响应（500KB-1MB 压缩）- 压缩格式 + 详细建议
+    if (compactSize < RESPONSE_SIZE_MAX) {
+        const suggestions = getOptimizationSuggestions(toolName, args, result, stats);
+        let header = `🚨 Very large response: ${sizeKB}KB\n`;
+        header += `This may cause performance issues and exceed context limits.\n`;
+        if (stats.meta) {
+            header += `\n📊 Data: ${stats.meta.count} items returned`;
+            if (stats.meta.totalMatched > stats.meta.count) {
+                header += ` (${stats.meta.totalMatched} matched, ${stats.meta.totalInBuffer} in buffer)`;
+            }
+        }
+        if (stats.largestFields && stats.largestFields.length > 0) {
+            header += `\nLargest fields per item:`;
+            stats.largestFields.forEach(f => {
+                header += `\n  • ${f.path}: ~${Math.round(f.size / 1024)}KB`;
+            });
+        }
+        header += `\n\n🎯 STRONGLY RECOMMENDED optimizations:`;
+        if (suggestions.length > 0) {
+            header += suggestions.map((s, i) => `\n  ${i + 1}. ${s}`).join('');
+        }
+        else {
+            header += `\n  1. Reduce the amount of data requested`;
+            header += `\n  2. Use filtering parameters to narrow results`;
+        }
+        return [
+            {
+                type: 'text',
+                text: `${header}\n\n${'─'.repeat(60)}\n\n${compactStr}`,
+            },
+        ];
+    }
+    // 策略 5: 超超大响应（>1MB 压缩）- 截断 + 错误级别建议
+    const truncateSize = RESPONSE_SIZE_MAX;
+    const truncatedStr = compactStr.substring(0, truncateSize);
+    const suggestions = getOptimizationSuggestions(toolName, args, result, stats);
+    let header = `🛑 Response too large: ${sizeKB}KB (TRUNCATED to ${Math.round(truncateSize / 1024)}KB)\n`;
+    header += `Original size: ${sizeKB}KB, showing only ${Math.round(truncateSize / 1024)}KB\n`;
+    header += `\n⚠️ This response is unusable at this size. You MUST optimize the request.\n`;
+    if (stats.meta) {
+        header += `\n📊 Data: ${stats.meta.count} items (${stats.meta.totalMatched} matched, ${stats.meta.totalInBuffer} in buffer)`;
+    }
+    if (stats.largestFields && stats.largestFields.length > 0) {
+        header += `\nLargest fields per item:`;
+        stats.largestFields.forEach(f => {
+            header += `\n  • ${f.path}: ~${Math.round(f.size / 1024)}KB (${Math.round((f.size / compactSize) * 100)}% of total)`;
+        });
+    }
+    header += `\n\n🎯 REQUIRED actions:`;
+    if (suggestions.length > 0) {
+        header += suggestions.map((s, i) => `\n  ${i + 1}. ${s}`).join('');
+    }
+    else {
+        header += `\n  1. Significantly reduce the data requested`;
+        header += `\n  2. Use "fields" to extract only essential data`;
+        header += `\n  3. Add filters to narrow down results`;
+    }
+    return [
+        {
+            type: 'text',
+            text: `${header}\n\n${'─'.repeat(60)}\n\n${truncatedStr}\n\n... <TRUNCATED ${sizeKB - Math.round(truncateSize / 1024)}KB>`,
+        },
+    ];
+}
+async function main() {
+    // 解析命令行参数
+    const { extensionId: _extensionId, uninstall, configure } = parseArgs();
+    // 如果是配置命令，执行配置脚本并退出
+    if (configure) {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const configureScript = join(__dirname, 'configure.js');
+        // 透传 configure 子命令参数（例如 --extension-id / --skip-mcp / --get）
+        const configureArgs = process.argv
+            .slice(2)
+            .filter(arg => arg !== 'configure' && arg !== '--configure');
+        const child = spawn('node', [configureScript, ...configureArgs], {
+            stdio: 'inherit',
+        });
+        child.on('exit', code => {
+            process.exit(code || 0);
+        });
+        return;
+    }
+    // 如果是卸载命令，执行卸载脚本并退出
+    if (uninstall) {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const uninstallScript = join(__dirname, 'uninstall.js');
+        const child = spawn('node', [uninstallScript], {
+            stdio: 'inherit',
+        });
+        child.on('exit', code => {
+            process.exit(code || 0);
+        });
+        return;
+    }
+    // 初始化日志文件
+    writeFileSync(LOG_FILE, `=== Mearl MCP Server Started at ${new Date().toISOString()} ===\n`);
+    log('Starting Mearl MCP Server...');
+    log('MCP Server initialized, will connect to Chrome Extension when tools are called');
+    // 创建 MCP Server
+    const server = new Server({
+        name: 'mearl',
+        version: '1.0.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+        instructions: '浏览器交互默认工作流：首次进入页面时使用 browser_page_snapshot 建立页面基线；后续点击、输入、悬停、滚动、按键和上传直接使用 browser_page_click/type/hover/scroll/press/upload，它们默认内置观察，动作与异步稳定判断在一次调用内完成，返回 { action, observation }；传 observe:false 可关闭观察仅执行裸动作。观察结果不替代完整页面理解：observation.mode 为 delta 时确认 scope="main-document"，再读取 effects.notifications、effects.interactives 和 effects.focus；notifications 中 change=transient 表示已经消失的 Toast、状态或错误提示。为 navigation 时先检查 ready，ready=true 表示文档、相关业务请求和可见骨架状态已经稳定，可在新页面重建 snapshot。其他情况下仅当 fullSnapshotRecommended 为 true 时根据 snapshotReasons 回退，并选择最小范围：已知区域用 rootSelector，长列表用 mode="viewport"，只需控件用 mode="interactive"；缺少 AX 控件语义时 interactive 会在同一次调用中回退到 viewport，并返回 fallbackMode。视觉任务再使用 screenshot。不要在每次动作后固定调用 browser_page_wait、snapshot 或 screenshot。',
+    });
+    // 页面交互工具共享的 observe 参数 schema：默认开启内置观察，传 false 关闭
+    const OBSERVE_INPUT_SCHEMA = {
+        type: ['object', 'boolean'],
+        description: '观察选项。默认开启内置观察（等待相关 DOM、XHR/Fetch/MTop 请求或导航稳定后返回页面变化信号）；传 false 关闭观察，仅执行裸动作并直接返回其结果',
+        properties: {
+            quietMs: {
+                type: 'number',
+                description: '最后一次 DOM 变化后等待的稳定窗口，默认 100ms',
+            },
+            firstChangeTimeoutMs: {
+                type: 'number',
+                description: '没有发生 DOM 变化时最多等待多久，默认 500ms',
+            },
+            timeoutMs: {
+                type: 'number',
+                description: '整个观察阶段的最大时间，默认 3000ms',
+            },
+            navigationGraceMs: {
+                type: 'number',
+                description: '低信息量点击或按键后等待导航开始的基础宽限时间，默认 1000ms；若仍有网络活动会自动延长，有明确 effects 时不等待',
+            },
+            navigationTimeoutMs: {
+                type: 'number',
+                description: '导航开始后等待页面就绪的最大时间，默认 15000ms',
+            },
+            networkIdleMs: {
+                type: 'number',
+                description: '文档加载完成且相关 XHR/Fetch/MTop 请求归零后继续保持静默的时间，默认 500ms，用于跳过业务骨架屏',
+            },
+            contentReadyAfterMs: {
+                type: 'number',
+                description: '动作开始后允许用结构稳定兜底的保护期，默认 5000ms，并自动限制在导航超时之前；保护期内仍优先等待网络静默',
+            },
+        },
+    };
+    // 定义工具列表
+    const tools = [
+        {
+            name: 'browser_get_requests',
+            description: '获取浏览器中最近的 API 请求历史记录，包含完整的请求和响应信息。适用于分析性能、排查问题、查看数据流等场景。无需等待用户操作，立即返回已有数据。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    count: {
+                        type: 'number',
+                        description: '获取的请求数量，默认 10 个。最多可获取最近 1000 个请求',
+                        default: 10,
+                    },
+                    filter: {
+                        type: 'string',
+                        description: '过滤 API 名称的正则表达式（可选）。例如: ".*\\.cart\\..*" 只返回购物车相关接口',
+                    },
+                    since: {
+                        type: 'number',
+                        description: '从多久之前开始获取（秒）。例如: 60 表示获取最近 1 分钟内的请求',
+                    },
+                    includeBody: {
+                        type: 'boolean',
+                        description: '是否包含请求体和响应体。false 时将省略 postData 和 responseBody 字段以减少数据量。默认 true',
+                        default: true,
+                    },
+                    includeHeaders: {
+                        type: 'boolean',
+                        description: '是否包含请求头和响应头。false 时将省略 headers 和 responseHeaders 字段以减少数据量。默认 false',
+                        default: false,
+                    },
+                    maxBodySize: {
+                        type: 'number',
+                        description: '单个请求/响应体的最大字节数。超过此大小将被截断。默认 50000（约 50KB）',
+                        default: 50000,
+                    },
+                    fields: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                        description: '从响应体中提取指定字段，支持点号路径。例如: ["data.result.list", "data.total"] 只返回这些字段，大幅减少数据量',
+                    },
+                    keysOnly: {
+                        type: 'boolean',
+                        description: '只返回数据结构（字段路径和类型），不返回实际值。设为 true 可先预览数据结构，再决定提取哪些字段。默认 false',
+                        default: false,
+                    },
+                    source: {
+                        type: 'string',
+                        enum: ['mtop', 'requests'],
+                        description: '数据源。mtop: mtop 接口（默认）; requests: 普通 XHR/Fetch 请求。不传则使用 DevTools panel 当前所处模式',
+                    },
+                },
+            },
+        },
+        {
+            name: 'browser_get_events',
+            description: '获取浏览器中最近的 RUM/aplus 埋点事件，包含页面资源性能指标、用户行为埋点、SPM 点击事件等。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    source: {
+                        type: 'string',
+                        enum: ['rum', 'aplus', 'all'],
+                        description: '事件来源。rum: RUM 性能监控事件; aplus: aplus 埋点事件; all: 全部（默认）',
+                        default: 'all',
+                    },
+                    event_type: {
+                        type: 'string',
+                        description: '事件类型正则过滤。例如: "rum/view" 匹配页面 view 事件, "aplus/CLK" 匹配点击埋点',
+                    },
+                    filter: {
+                        type: 'string',
+                        description: '正则过滤，匹配事件的 name 或 url 字段',
+                    },
+                    since: {
+                        type: 'number',
+                        description: '从多久之前开始获取（秒）。例如: 60 表示获取最近 1 分钟内的事件',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: '返回条数上限，默认 20',
+                        default: 20,
+                    },
+                },
+            },
+        },
+        {
+            name: 'browser_get_logs',
+            description: '获取浏览器控制台日志（console.log/warn/error/info）。适用于排查前端错误、调试代码执行流程、查看调试信息等场景。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    level: {
+                        type: 'string',
+                        enum: ['log', 'warn', 'error', 'info', 'all'],
+                        description: '日志级别过滤。log: 普通日志, warn: 警告, error: 错误, info: 信息, all: 所有级别。默认 all',
+                        default: 'all',
+                    },
+                    since: {
+                        type: 'number',
+                        description: '从多久之前开始获取日志（秒）。例如: 60 表示获取最近 1 分钟内的日志',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: '最大返回日志数量，默认 100。避免返回过多数据',
+                        default: 100,
+                    },
+                    filter: {
+                        type: 'string',
+                        description: '过滤日志内容的正则表达式或字符串（可选）。支持正则表达式模式（不区分大小写），若正则无效则回退到字符串包含匹配。例如: "error|warning" 匹配包含 error 或 warning 的日志',
+                    },
+                },
+            },
+        },
+        {
+            name: 'browser_set_mock',
+            description: '动态设置 API 接口的 Mock 数据，用于测试不同数据场景。修改后，浏览器中对该接口的所有请求都会返回 Mock 数据。适用于前端开发测试、边界情况验证、UI 状态测试等。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    apiName: {
+                        type: 'string',
+                        description: 'API 名称或正则表达式模式。例如: "mtop.cart.query" 精确匹配, ".*\\.cart\\..*" 匹配所有购物车接口',
+                    },
+                    mockData: {
+                        type: ['object', 'string'],
+                        description: '【方式一】直接设置完整 Mock 响应数据（JSON 对象）。传入后该接口将完全返回此数据，不再请求真实服务端。示例: {"data":{"result":{"list":[]}},"ret":["SUCCESS"]}。注意：mockData 和 fields 二选一，同时提供时优先使用 fields。大体积响应体可传文件引用字符串 "@/abs/resp.json"（从该文件读取，建议绝对路径）以减少上下文占用',
+                    },
+                    fields: {
+                        type: 'array',
+                        description: '【方式二】基于真实响应修改指定字段。系统会先获取该接口的原始响应数据，然后按指定路径修改字段值。适合在真实数据基础上做微调',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                path: {
+                                    type: 'string',
+                                    description: '字段路径，支持点号和数组索引。例如: "data.result.passengerList[0].name.text"',
+                                },
+                                value: {
+                                    description: '要设置的值，可以是任意类型（字符串、数字、对象、数组等）',
+                                },
+                            },
+                            required: ['path', 'value'],
+                        },
+                    },
+                    enabled: {
+                        type: 'boolean',
+                        description: '是否启用 Mock。true: 启用 Mock, false: 禁用 Mock 恢复真实数据。默认 true',
+                        default: true,
+                    },
+                    duration: {
+                        type: 'number',
+                        description: '完整响应时长（毫秒）。可选，mock 生效时的总耗时，绕过真实服务器精确控制（用于测试加载状态、超时等场景）',
+                    },
+                    conditions: {
+                        type: 'object',
+                        additionalProperties: true,
+                        description: '请求 query/body 字段的子集匹配规则；保留字段 $index 从 0 开始指定同一场景的调用顺序。相同 $index 再次设置会原地覆盖，超过最后一项后持续使用最后一项',
+                    },
+                    payloadFile: {
+                        type: 'string',
+                        description: '从文件读取 mock 数据（JSON 格式）。当 mockData 很大时，可将完整 JSON 写入文件，通过此参数指定文件路径。文件内容会被解析为 mockData。注意：此参数与 mockData/fields 互斥，优先级最高',
+                    },
+                },
+                required: ['apiName'],
+            },
+        },
+        {
+            name: 'browser_get_mocks',
+            description: '查看当前所有已设置的 Mock 配置，包括接口名称、是否启用、以及 Mock 数据内容。用于排查 Mock 是否生效、Mock 数据是否正确等问题。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    apiName: {
+                        type: 'string',
+                        description: '过滤指定接口，支持正则表达式。例如: "mtop.cart.query" 或 ".*\\.cart\\..*"。不传则返回所有 Mock',
+                    },
+                },
+            },
+        },
+        {
+            name: 'browser_send_request',
+            description: '通过浏览器发起 HTTP 代理请求，自动携带目标域名的 Cookie（使用当前浏览器登录态）。支持 GET/POST/PUT/DELETE/PATCH 等方法，适用于需要用户登录态的接口调试、数据爬取、接口测试等场景。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    url: {
+                        type: 'string',
+                        description: '目标请求 URL，必须是完整 URL（含 http:// 或 https://）',
+                    },
+                    method: {
+                        type: 'string',
+                        enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'],
+                        description: 'HTTP 请求方法，默认 GET',
+                        default: 'GET',
+                    },
+                    headers: {
+                        type: 'object',
+                        description: '自定义请求头（键值对），会与自动生成的 Cookie 头合并',
+                        additionalProperties: { type: 'string' },
+                    },
+                    params: {
+                        type: 'object',
+                        description: 'URL 查询参数（键值对），会追加到 URL 中',
+                        additionalProperties: { type: 'string' },
+                    },
+                    body: {
+                        description: '请求体。传入对象时自动序列化为 JSON 并设置 Content-Type: application/json；传入字符串时原样发送',
+                    },
+                    withCookies: {
+                        type: 'boolean',
+                        description: '是否自动携带浏览器中该域名的 Cookie，默认 true',
+                        default: true,
+                    },
+                    cookieDomain: {
+                        type: 'string',
+                        description: '指定获取 Cookie 的域名（默认从 url 中自动提取域名）',
+                    },
+                    responseType: {
+                        type: 'string',
+                        enum: ['json', 'text', 'auto'],
+                        description: '响应格式。auto: 自动检测（默认）; json: 强制解析为 JSON; text: 返回原始文本。注意：auto 模式下若 Content-Type 为图片/音视频/PDF/压缩包等二进制类型，body 将以 base64 字符串返回，bodyType 为 "base64"',
+                        default: 'auto',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: '请求超时时间（毫秒），默认 30000（30 秒）',
+                        default: 30000,
+                    },
+                },
+                required: ['url'],
+            },
+        },
+        {
+            name: 'browser_send_mtop_request',
+            description: '在当前浏览器页面上下文中发起 mtop API 请求。自动处理签名计算（md5）、Cookie 中的 token 提取、时间戳生成等，无需手动构造签名。适用于：调试 mtop 接口、验证接口返回数据、测试不同参数组合等场景。注意：需要当前页面已登录（有对应的 Cookie），且 DevTools 面板已打开。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    api: {
+                        type: 'string',
+                        description: 'mtop API 名称，例如: "mtop.trade.order.create"、"mtop.fliggy.flyrs.render"。以 "mopen." 开头的会使用 mopen 签名算法',
+                    },
+                    data: {
+                        description: '请求数据（JSON 对象），即 mtop 请求中的 data 参数。例如: {"itemId": "12345"}',
+                    },
+                    version: {
+                        type: 'string',
+                        description: 'API 版本号，默认 "1.0"',
+                        default: '1.0',
+                    },
+                    method: {
+                        type: 'string',
+                        enum: ['GET', 'POST'],
+                        description: 'HTTP 请求方法，默认 GET。POST 时 data 参数放在请求体中',
+                        default: 'GET',
+                    },
+                    appKey: {
+                        type: 'string',
+                        description: 'appKey，默认 "12574478"',
+                    },
+                    env: {
+                        type: 'string',
+                        enum: ['online', 'pre'],
+                        description: '请求环境。online: 线上（默认，h5api.m.taobao.com）; pre: 预发（h5api.wapa.taobao.com）',
+                        default: 'online',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: '请求超时时间（毫秒），默认 10000（10 秒）',
+                        default: 10000,
+                    },
+                },
+                required: ['api'],
+            },
+        },
+        {
+            name: 'browser_get_api_schema',
+            description: '获取 MTOP API 的请求参数 JSON Schema，用于生成接口调用代码。返回接口的完整参数定义，包括参数类型、是否必需、默认值等信息。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    api: {
+                        type: 'string',
+                        description: 'API 名称，例如: "mtop.fliggy.flyrs.render"',
+                    },
+                    version: {
+                        type: 'string',
+                        description: 'API 版本号，默认 "1.0"',
+                        default: '1.0',
+                    },
+                    fields: {
+                        type: 'array',
+                        items: { type: 'string', enum: ['schema', 'hsf'] },
+                        description: '指定返回哪些字段。schema: 请求参数 JSON Schema；hsf: HSF 接口信息（服务名、方法、版本）。不传则返回全部。',
+                    },
+                },
+                required: ['api'],
+            },
+        },
+        {
+            name: 'browser_set_rule',
+            description: '添加 Chrome declarativeNetRequest 规则，用于拦截、重定向或修改请求。规则持久化保存，浏览器重启后仍生效。支持：重定向请求到另一地址、修改请求/响应头、阻止请求、升级到 HTTPS 等。适用于：本地开发时代理到本地服务、修改请求头调试、拦截特定请求等。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    actionType: {
+                        type: 'string',
+                        enum: ['redirect', 'block', 'allow', 'upgradeScheme', 'modifyHeaders'],
+                        description: '规则类型。redirect: 重定向请求到另一地址; block: 阻止请求; allow: 允许请求; upgradeScheme: 升级到 HTTPS; modifyHeaders: 修改请求/响应头',
+                    },
+                    filter: {
+                        type: 'string',
+                        description: 'URL 匹配规则（正则表达式）。例如: "^https://h5api\\.m\\.taobao\\.com/.*" 匹配所有淘宝 h5api 请求',
+                    },
+                    redirectUrl: {
+                        type: 'string',
+                        description: '【redirect 类型必填】重定向目标 URL。支持正则替换占位符 \\1 \\2 等（引用 filter 中的捕获组）',
+                    },
+                    requestHeaders: {
+                        type: 'array',
+                        description: '【modifyHeaders 类型】要修改的请求头列表',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                header: { type: 'string', description: '请求头名称，如 "x-custom-header"' },
+                                operation: {
+                                    type: 'string',
+                                    enum: ['set', 'append', 'remove'],
+                                    description: 'set: 设置/覆盖; append: 追加; remove: 删除',
+                                },
+                                value: { type: 'string', description: '请求头值（remove 时可省略）' },
+                            },
+                            required: ['header', 'operation'],
+                        },
+                    },
+                    responseHeaders: {
+                        type: 'array',
+                        description: '【modifyHeaders 类型】要修改的响应头列表',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                header: { type: 'string', description: '响应头名称' },
+                                operation: {
+                                    type: 'string',
+                                    enum: ['set', 'append', 'remove'],
+                                    description: 'set: 设置/覆盖; append: 追加; remove: 删除',
+                                },
+                                value: { type: 'string', description: '响应头值（remove 时可省略）' },
+                            },
+                            required: ['header', 'operation'],
+                        },
+                    },
+                    initiatorDomains: {
+                        type: 'string',
+                        description: '发起请求的域名限制（逗号分隔）。只有从这些域名发起的请求才会匹配此规则。例如: "taobao.com,tmall.com"',
+                    },
+                    resourceTypes: {
+                        type: 'array',
+                        description: '资源类型限制。不填则匹配所有类型',
+                        items: {
+                            type: 'string',
+                            enum: [
+                                'main_frame',
+                                'sub_frame',
+                                'script',
+                                'stylesheet',
+                                'image',
+                                'xmlhttprequest',
+                                'websocket',
+                                'other',
+                            ],
+                        },
+                    },
+                    priority: {
+                        type: 'number',
+                        description: '规则优先级，数字越大优先级越高。多个规则匹配同一请求时，优先级高的生效。默认 1',
+                        default: 1,
+                    },
+                    description: {
+                        type: 'string',
+                        description: '规则描述，便于识别规则用途',
+                    },
+                },
+                required: ['actionType', 'filter'],
+            },
+        },
+        {
+            name: 'browser_get_rules',
+            description: '查看当前存储的全部请求规则（含用户在插件 Options 面板手动配置的）。返回规则总开关状态和规则列表，字段结构与 browser_set_rule 入参对齐，用于确认规则是否生效或排查请求被意外重定向/修改的问题。',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        },
+        {
+            name: 'browser_page_screenshot',
+            description: '获取当前浏览器活动标签页的视觉截图，以 Base64 编码返回。支持全页截图或指定 CSS 选择器截取单个元素（类似 DevTools "Capture node screenshot"）。适用于视觉判断、Canvas、跨域 iframe、UI 排查和保存快照；常规页面动作后优先读取其内置观察的增量结果，不要固定在每次动作后截图。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: 'CSS 选择器。提供后只截取该元素区域（会自动滚动元素到可见区域），不提供则截取整个页面',
+                    },
+                    format: {
+                        type: 'string',
+                        enum: ['png', 'jpeg'],
+                        description: '截图格式。png: PNG 格式（无损，默认）; jpeg: JPEG 格式（有损压缩，体积更小）',
+                        default: 'png',
+                    },
+                    quality: {
+                        type: 'number',
+                        description: 'JPEG 质量（仅 format 为 jpeg 时有效）。范围 0-100，默认 80。数值越高质量越好但文件越大',
+                        default: 80,
+                    },
+                },
+                required: ['tabId'],
+            },
+        },
+        {
+            name: 'browser_page_selected_element',
+            description: '获取 Chrome DevTools Elements 面板中当前选中元素的详细信息，包含布局尺寸、CSS 计算样式、属性、DOM 结构等。适用于：分析布局问题、排查样式异常、了解元素几何信息、辅助 UI 优化等场景。使用前需要在 Elements 面板中选中目标元素（点击面板元素或使用 inspect 工具点击页面元素）。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    includeOuterHTML: {
+                        type: 'boolean',
+                        description: '是否包含元素的 outerHTML（最多 3000 字符）。设为 false 可减少数据量。默认 true',
+                        default: true,
+                    },
+                    includeScreenshot: {
+                        type: 'boolean',
+                        description: '是否返回选中元素截图。开启后会自动滚动到元素并按默认策略截图（PNG、8px 边距），返回 image 类型内容。默认 false',
+                        default: false,
+                    },
+                },
+                required: ['tabId'],
+            },
+        },
+        {
+            name: 'get_user_info',
+            description: '获取当前登录用户的信息。默认只返回工号（userId），设置 detail 为 true 时返回完整的用户信息（姓名、花名、部门、BU 等）。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    detail: {
+                        type: 'boolean',
+                        description: '是否获取完整用户信息。默认 false（只返回工号）；设置为 true 时返回姓名、花名、部门、BU 等详细信息',
+                        default: false,
+                    },
+                },
+                required: [],
+            },
+        },
+        {
+            name: 'tdbank_account',
+            description: '通过 TDBank SSO 将当前浏览器登录为指定测试账号，供 taobao.com 及其子域页面使用。一个工具完成获取当前账号、账号列表、切换账号、快速借用并切换账号；使用前需要浏览器已登录 tdbank.alibaba-inc.com。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    operation: {
+                        type: 'string',
+                        enum: ['current', 'list', 'switch', 'borrow'],
+                        description: '操作类型。current=当前登录账号，list=账号列表，switch=通过 TDBank SSO 切换 taobao.com 系页面账号，borrow=快速借用并登录该账号',
+                        default: 'list',
+                    },
+                    refresh: {
+                        type: 'boolean',
+                        description: 'list 时是否强制刷新账号列表，默认 false',
+                        default: false,
+                    },
+                    pageIndex: {
+                        type: 'number',
+                        description: 'list 时的页码，默认 1',
+                        default: 1,
+                    },
+                    accountId: {
+                        type: ['string', 'number'],
+                        description: 'switch 时使用账号列表中的 id',
+                    },
+                    havanaId: {
+                        type: ['string', 'number'],
+                        description: 'switch 时也可直接指定 havanaId；此时 site 必填',
+                    },
+                    site: {
+                        type: ['string', 'number'],
+                        description: '直接指定 havanaId 时必填，账号列表中的 site 也会自动使用',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'borrow 时输入要借用的账号 loginId 或关键词',
+                    },
+                    tabId: {
+                        type: 'number',
+                        description: 'CDP 模式下可指定用于读取 Cookie 的标签页 ID',
+                    },
+                },
+            },
+        },
+        {
+            name: 'browser_launch',
+            description: '启动一个拥有独立 Profile 的托管 Chrome 浏览器。默认 headless，可复用当前控制浏览器的 TDBank 登录态，通过 SSO 为新浏览器登录指定测试账号，供 taobao.com 及其子域页面使用；多个实例之间 Cookie 和存储完全隔离。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: '实例名称，后续可用 browser_select_browser 按名称或返回的 browserId 选择',
+                    },
+                    headless: {
+                        type: 'boolean',
+                        description: '是否使用 headless=new，默认 true',
+                        default: true,
+                    },
+                    userAgentMode: {
+                        type: 'string',
+                        enum: ['default', 'desktop'],
+                        description: 'UA 模式：default 使用 Chrome 默认 UA，desktop 使用匹配本机 Chrome 版本和宿主平台的桌面 UA',
+                        default: 'default',
+                    },
+                    persistent: {
+                        type: 'boolean',
+                        description: '关闭后是否保留独立 Profile，默认 false；false 时自动清理',
+                        default: false,
+                    },
+                    url: {
+                        type: 'string',
+                        description: 'TDBank SSO 登录完成后在新浏览器打开的初始 URL，通常为 taobao.com 系页面',
+                    },
+                    executablePath: {
+                        type: 'string',
+                        description: 'Chrome 可执行文件路径；省略时自动发现，也可用环境变量配置',
+                    },
+                    accountId: {
+                        type: ['string', 'number'],
+                        description: 'TDBank 账号列表中的 accountId',
+                    },
+                    havanaId: {
+                        type: ['string', 'number'],
+                        description: '直接指定 havanaId；同时必须提供 site',
+                    },
+                    site: {
+                        type: ['string', 'number'],
+                        description: 'havanaId 对应的站点',
+                    },
+                    query: {
+                        type: 'string',
+                        description: '按 loginId/关键词搜索、借用并登录 TDBank 账号',
+                    },
+                    tabId: {
+                        type: 'number',
+                        description: 'CDP 控制浏览器中用于读取 TDBank Cookie 的标签页 ID',
+                    },
+                    copyCookieDomains: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: '从控制浏览器复制到新实例的 Cookie 域名列表。保留 HttpOnly/Secure/SameSite/过期时间等属性；非内置域需先授权。可与 TDBank 登录组合，复制先执行、TDBank SSO 后执行。',
+                    },
+                },
+                required: ['name'],
+            },
+        },
+        {
+            name: 'browser_close',
+            description: '关闭一个托管浏览器；临时 Profile 自动删除，持久化 Profile 可显式删除。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    browser: {
+                        type: 'string',
+                        description: 'browser_launch 返回的 browserId 或实例名称',
+                    },
+                    deleteProfile: {
+                        type: 'boolean',
+                        description: '是否强制删除持久化 Profile，默认 false',
+                        default: false,
+                    },
+                },
+                required: ['browser'],
+            },
+        },
+        {
+            name: 'browser_tab_open',
+            description: '打开或按 URL 规则复用标签页。默认新建并等待加载完成；reuse=prefer 可优先复用，reuse=require 可限制为只复用。响应的 opened/reused 可用于判断流程结束时是否应关闭该 Tab。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    url: {
+                        type: 'string',
+                        description: '要打开的页面 URL',
+                    },
+                    active: {
+                        type: 'boolean',
+                        description: '是否激活（前台显示）新标签页。默认 false（后台打开）',
+                        default: false,
+                    },
+                    closeExisting: {
+                        type: 'boolean',
+                        description: '打开前是否先关闭 Agent 受控的已有标签页。默认 false',
+                        default: false,
+                    },
+                    group: {
+                        type: 'string',
+                        description: '把新标签页加入指定标题的标签页分组（同窗口同名分组存在则加入，否则新建）。仅扩展模式支持，CDP 模式忽略',
+                    },
+                    reuse: {
+                        type: 'string',
+                        enum: ['never', 'prefer', 'require'],
+                        description: 'never 始终新建；prefer 匹配到则复用、否则新建；require 只允许复用。默认 never',
+                        default: 'never',
+                    },
+                    match: {
+                        type: 'object',
+                        description: '复用标签页时的 URL 匹配规则',
+                        properties: {
+                            urlPattern: {
+                                type: 'string',
+                                description: '支持 * 的完整 URL glob；省略时精确匹配 url',
+                            },
+                            ignoreSearch: {
+                                type: 'boolean',
+                                description: '匹配时是否忽略 URL query，默认 false',
+                            },
+                            ignoreHash: {
+                                type: 'boolean',
+                                description: '匹配时是否忽略 URL hash，默认 false',
+                            },
+                            onMultiple: {
+                                type: 'string',
+                                enum: ['error', 'first'],
+                                description: '匹配多个 Tab 时默认报错；first 显式取第一个',
+                            },
+                        },
+                    },
+                    restoreFocusOnClose: {
+                        type: 'boolean',
+                        description: '新建 active Tab 关闭后是否恢复原活动标签页，默认 false',
+                        default: false,
+                    },
+                    emulation: {
+                        type: 'object',
+                        description: '开 tab 即进入移动端模拟态（视口/DPR/UA/触摸），等价于随后立即调用 browser_set_device_emulation，但在导航前生效，页面首屏就是移动态、无需 reload。字段规则与 browser_set_device_emulation 一致（无 enabled，开 tab 即启用）。',
+                        properties: {
+                            preset: {
+                                type: 'string',
+                                enum: ['iphone-15-pro', 'iphone-se', 'pixel-8', 'ipad-mini', 'galaxy-s23'],
+                                description: '内置设备预设，一键提供 viewport/DPR/UA。可与下面字段组合，显式字段覆盖预设值',
+                            },
+                            width: { type: 'number', description: '视口宽度（覆盖 preset）' },
+                            height: { type: 'number', description: '视口高度（覆盖 preset）' },
+                            deviceScaleFactor: { type: 'number', description: 'devicePixelRatio（覆盖 preset）' },
+                            mobile: {
+                                type: 'boolean',
+                                description: '是否启用移动渲染模式。默认从 preset 推断，无 preset 默认 true',
+                            },
+                            userAgent: {
+                                type: 'string',
+                                description: '自定义 User-Agent（覆盖 preset）。无 preset 时必填',
+                            },
+                            orientation: {
+                                type: 'string',
+                                enum: ['portrait', 'landscape'],
+                                description: '横竖屏，landscape 会对调宽高。默认 portrait',
+                            },
+                            touch: {
+                                type: 'boolean',
+                                description: '是否启用触摸事件并把鼠标事件转成 touch。默认 mobile 为真时启用',
+                            },
+                        },
+                    },
+                },
+                required: ['url'],
+            },
+        },
+        {
+            name: 'browser_tab_close',
+            description: '关闭指定的浏览器标签页。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '要关闭的标签页 ID（从 tab_open 或 tab_list 获取）',
+                    },
+                },
+                required: ['tabId'],
+            },
+        },
+        {
+            name: 'browser_tab_list',
+            description: '列出当前浏览器窗口中所有标签页的信息，包括 ID、URL、标题和是否活动。',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        },
+        {
+            name: 'browser_page_click',
+            description: '点击页面元素，默认内置观察：同一次调用内等待相关 DOM、XHR/Fetch/MTop 请求或导航稳定，返回 { action, observation }；传 observe:false 仅执行裸点击。定位方式三选一：selector（CSS 或 @eN snapshot ref）、text（按可见文本匹配 accessibility name）、point（视口坐标）。selector/@ref 默认走 el.click()；clickType:"cdp" 时改用真实 mouse/touch 事件。text/point 始终使用真实输入事件。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: '原生 CSS 选择器（如 "[aria-label=\'提交\']"、"#login-btn"）或 snapshot ref（如 "@e3"，必须带 "@" 前缀）。注意字段名是 "selector" 而非 "ref"。不支持 :has-text/:visible 等 Playwright 扩展语法。与 text/point 互斥。',
+                    },
+                    text: {
+                        type: 'string',
+                        description: '按可见文本（accessibility name）定位。例如 "退款明细"。匹配到多个时会报错并列出候选——可加 role 或 exact:true 收敛，或用 page_snapshot 拿 @ref。与 selector/point 互斥。',
+                    },
+                    point: {
+                        type: 'object',
+                        description: '按视口坐标点击（CSS 像素，左上角为原点）。selector 和 text 都不适用时使用。与 selector/text 互斥。',
+                        properties: {
+                            x: { type: 'number', description: '横坐标（CSS 像素）' },
+                            y: { type: 'number', description: '纵坐标（CSS 像素）' },
+                        },
+                        required: ['x', 'y'],
+                    },
+                    role: {
+                        type: 'string',
+                        description: '配合 text 使用，按 AX role 过滤消歧（如 "button"、"link"、"heading"、"StaticText"）',
+                    },
+                    exact: {
+                        type: 'boolean',
+                        description: '配合 text 使用，默认 true 精确匹配；false 时按子串匹配',
+                        default: true,
+                    },
+                    clickType: {
+                        type: 'string',
+                        enum: ['js', 'cdp'],
+                        description: '点击方式。默认 js：对 selector/@ref 调用 el.click()；cdp：派发真实 mouse/touch 事件。text/point 始终用 cdp',
+                        default: 'js',
+                    },
+                    observe: OBSERVE_INPUT_SCHEMA,
+                },
+                required: ['tabId'],
+            },
+        },
+        {
+            name: 'browser_page_type',
+            description: '向输入框填写文本，默认内置观察（校验提示等异步变化），返回 { action, observation }；传 observe:false 仅执行裸输入。兼容 React 等框架的受控组件，会自动触发 input 和 change 事件。selector 支持原生 CSS 或 "@eN" snapshot ref。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: '原生 CSS 选择器或 snapshot ref（如 "@e6"，必须带 "@" 前缀）。字段名是 "selector"。不支持 :has-text/:visible 等 Playwright 扩展。',
+                    },
+                    text: {
+                        type: 'string',
+                        description: '要输入的文本内容',
+                    },
+                    clearFirst: {
+                        type: 'boolean',
+                        description: '是否先清空输入框原有内容。默认 true',
+                        default: true,
+                    },
+                    observe: OBSERVE_INPUT_SCHEMA,
+                },
+                required: ['tabId', 'selector', 'text'],
+            },
+        },
+        {
+            name: 'browser_page_scroll',
+            description: '滚动页面，默认内置观察（懒加载内容等变化），返回 { action, observation }；传 observe:false 仅执行裸滚动。支持 up、down、top、bottom 四个方向。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    direction: {
+                        type: 'string',
+                        enum: ['up', 'down', 'top', 'bottom'],
+                        description: '滚动方向',
+                    },
+                    distance: {
+                        type: 'number',
+                        description: '滚动距离（像素），仅 up/down 方向有效。默认 600',
+                        default: 600,
+                    },
+                    observe: OBSERVE_INPUT_SCHEMA,
+                },
+                required: ['tabId', 'direction'],
+            },
+        },
+        {
+            name: 'browser_page_hover',
+            description: '将鼠标悬停在元素上，默认内置观察（下拉菜单、提示等变化），返回 { action, observation }；传 observe:false 仅执行裸悬停。使用 CDP Input.dispatchMouseEvent 发送真实鼠标移动事件，selector 支持原生 CSS 或 "@eN" snapshot ref。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: '原生 CSS 选择器或 snapshot ref（如 "@e1"，必须带 "@" 前缀）。字段名是 "selector"。不支持 :has-text/:visible 等 Playwright 扩展。',
+                    },
+                    observe: OBSERVE_INPUT_SCHEMA,
+                },
+                required: ['tabId', 'selector'],
+            },
+        },
+        {
+            name: 'browser_page_eval',
+            description: '在页面上下文中执行任意 JavaScript 表达式并返回结果。适用于：获取页面数据、操作 DOM、调用页面 API 等。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    expression: {
+                        type: 'string',
+                        description: '要执行的 JavaScript 表达式',
+                    },
+                    frameId: {
+                        type: 'string',
+                        description: '目标 frame 的 CDP frameId。不传则在主 frame 中执行。可通过 browser_page_frames 获取',
+                    },
+                    awaitPromise: {
+                        type: 'boolean',
+                        description: '是否等待表达式返回的 Promise，默认 true',
+                        default: true,
+                    },
+                },
+                required: ['tabId', 'expression'],
+            },
+        },
+        {
+            name: 'browser_page_snapshot',
+            description: '获取页面无障碍树，返回角色、名称、值、状态和 @ref。默认 mode="full" 建立完整基线；长列表可用 mode="viewport"，表单可用 mode="interactive"，已知弹层或区域可用 rootSelector 获取局部子树。页面缺少 AX 控件语义时 interactive 会自动回退到 viewport，并返回 fallbackMode="viewport"。后续交互依赖页面交互工具内置的观察结果，仅在建议回退、导航或 ref 失效时再次调用。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    depth: {
+                        type: 'number',
+                        description: '无障碍树的最大深度。默认 15，增大可获取更深层元素',
+                        default: 15,
+                    },
+                    mode: {
+                        type: 'string',
+                        enum: ['full', 'interactive', 'viewport'],
+                        description: '输出范围：full 为完整树；interactive 优先保留语义控件，无 AX 控件语义时自动回退到 viewport；viewport 只保留当前可视区域。默认 full',
+                    },
+                    rootSelector: {
+                        type: 'string',
+                        description: '只获取指定 CSS 元素的 AX 子树，可与 mode 组合',
+                    },
+                    maxNodes: {
+                        type: 'number',
+                        description: '最多输出节点数；超出时保留首尾。0 表示不限制',
+                    },
+                    maxChars: {
+                        type: 'number',
+                        description: '最多输出字符数，默认 60000；超出时保留首尾。0 表示不限制',
+                    },
+                },
+                required: ['tabId'],
+            },
+        },
+        {
+            name: 'browser_page_press',
+            description: '在页面中按下键盘按键，默认内置观察（提交、关闭弹窗等结果），返回 { action, observation }；传 observe:false 仅执行裸按键。支持单个按键和组合键。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    key: {
+                        type: 'string',
+                        description: '按键名称。支持：Enter, Tab, Escape, Backspace, Delete, ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Home, End, PageUp, PageDown, Space',
+                    },
+                    modifiers: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: '修饰键数组，如 ["Alt", "Shift", "Control", "Meta"]',
+                    },
+                    observe: OBSERVE_INPUT_SCHEMA,
+                },
+                required: ['tabId', 'key'],
+            },
+        },
+        {
+            name: 'browser_page_wait',
+            description: '独立等待接口：仅用于没有前置动作时等待指定时间、已知 selector 或页面 condition。三种模式必须且只能提供一个；点击、输入后的异步稳定判断由页面交互工具内置的观察完成。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    time: {
+                        type: 'number',
+                        description: '固定等待毫秒数，与 selector/condition 三选一',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: 'CSS 选择器，等待该元素出现在 DOM 中，与 time/condition 三选一',
+                    },
+                    condition: {
+                        type: 'string',
+                        description: '在页面主上下文轮询的 JavaScript 表达式，返回 truthy 时结束，支持 Promise；与 time/selector 三选一',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: '等待超时时间（毫秒），默认 10000ms',
+                        default: 10000,
+                    },
+                    interval: {
+                        type: 'number',
+                        description: 'selector/condition 的轮询间隔（毫秒），默认 200ms',
+                        default: 200,
+                    },
+                },
+                required: ['tabId'],
+            },
+        },
+        {
+            name: 'browser_page_navigate',
+            description: '在指定标签页中导航到新的 URL；或设置 refresh:true 直接重新加载当前页面（无需 url）。返回导航结果，可用于验证页面是否成功加载。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    url: {
+                        type: 'string',
+                        description: '要导航到的 URL。refresh 为 true 时可省略（此时刷新当前页面）',
+                    },
+                    refresh: {
+                        type: 'boolean',
+                        description: '为 true 时直接重新加载当前页面（忽略 url），用于刷新页面。默认 false',
+                        default: false,
+                    },
+                },
+                required: ['tabId'],
+            },
+        },
+        {
+            name: 'browser_page_upload',
+            description: '向 <input type="file"> 上传单个或多个文件（通过 CDP DOM.setFileInputFiles），默认内置观察（上传状态变化），返回 { action, observation }；传 observe:false 仅执行裸上传。selector 支持原生 CSS 或 "@eN" snapshot ref。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: '原生 CSS 选择器或 snapshot ref（如 "@e5"，必须带 "@" 前缀），用于定位 <input type="file"> 元素。字段名是 "selector"。',
+                    },
+                    filePaths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: '要上传的本地文件路径数组，如 ["/Users/me/photo.jpg"]',
+                    },
+                    observe: OBSERVE_INPUT_SCHEMA,
+                },
+                required: ['tabId', 'selector', 'filePaths'],
+            },
+        },
+        {
+            name: 'browser_page_frames',
+            description: '列出当前页面中所有 frame（主 frame + iframe）。返回每个 frame 的 frameId、URL、名称等信息。适用于：了解页面是否包含 iframe、获取 iframe 的 frameId 以便在 browser_page_eval 中指定执行上下文。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                },
+                required: ['tabId'],
+            },
+        },
+        {
+            name: 'browser_set_device_emulation',
+            description: '把目标标签页切换为移动端模拟态：视口尺寸 / DPR / UA / 触摸事件全部按指定设备生效，等价于 Chrome DevTools 设备工具栏，作用域仅限该 tab，会话结束自动还原。适用于：调试 H5 移动页面、让 page_click 在 swiper/fastclick 等只听 touchstart 的页面生效、让服务端按移动 UA 返回数据。启用后默认 reload 一次让页面以移动模式重新初始化。enabled=false 清除模拟。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    enabled: {
+                        type: 'boolean',
+                        description: '必填。true=启用模拟（按 preset/参数生效），false=清除模拟回到桌面态',
+                    },
+                    preset: {
+                        type: 'string',
+                        enum: ['iphone-15-pro', 'iphone-se', 'pixel-8', 'ipad-mini', 'galaxy-s23'],
+                        description: '内置设备预设，一键提供 viewport/DPR/UA。可与下面的字段组合，显式字段会覆盖预设值',
+                    },
+                    width: { type: 'number', description: '视口宽度（覆盖 preset）' },
+                    height: { type: 'number', description: '视口高度（覆盖 preset）' },
+                    deviceScaleFactor: { type: 'number', description: 'devicePixelRatio（覆盖 preset）' },
+                    mobile: {
+                        type: 'boolean',
+                        description: '是否启用移动渲染模式（影响 hover/pointer media query、viewport meta 行为）。默认从 preset 推断，无 preset 默认 true',
+                    },
+                    userAgent: { type: 'string', description: '自定义 User-Agent（覆盖 preset）' },
+                    orientation: {
+                        type: 'string',
+                        enum: ['portrait', 'landscape'],
+                        description: '横竖屏，landscape 会对调宽高。默认 portrait',
+                    },
+                    touch: {
+                        type: 'boolean',
+                        description: '是否启用触摸事件并把鼠标事件转成 touch。默认 mobile 为真时启用',
+                    },
+                    reload: {
+                        type: 'boolean',
+                        description: '启用模拟后是否重载页面（让 JS 读到新的 navigator.userAgent / window.innerWidth）。默认 true',
+                    },
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                },
+                required: ['tabId', 'enabled'],
+            },
+        },
+        {
+            name: 'browser_set_timezone',
+            description: '覆盖目标标签页的时区，作用域仅限该 tab，立即影响 Date / Intl 等页面时间 API。timezone 使用 IANA 时区标识（如 Asia/Shanghai、America/New_York）；传空字符串恢复浏览器默认时区。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    tabId: {
+                        type: 'number',
+                        description: '目标标签页 ID（从 browser_tab_open 或 browser_tab_list 获取）',
+                    },
+                    timezone: {
+                        type: 'string',
+                        description: 'IANA 时区标识；空字符串表示清除覆盖',
+                    },
+                },
+                required: ['tabId', 'timezone'],
+            },
+        },
+        {
+            name: 'browser_run_actions',
+            description: '批量顺序执行多个无需中间判断的原子操作，适合 hover→click 等必须紧密连续的序列。步骤内的页面动作不带内置观察；遇到第一个失败步骤立即停止，且不能嵌套 run_actions。若下一步需要根据页面变化决定，优先逐步使用带观察的页面交互工具；不要用本工具固化「点击→等待→截图」循环。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    actions: {
+                        type: 'array',
+                        description: '要依次执行的 action 列表',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                action: {
+                                    type: 'string',
+                                    description: 'action 名称（不带 browser_ 前缀），如 page_hover、page_click；仅组合无需中间判断的步骤',
+                                },
+                                data: {
+                                    type: 'object',
+                                    description: '该 action 的参数（与单独调用时相同）',
+                                },
+                            },
+                            required: ['action'],
+                        },
+                    },
+                    tabId: {
+                        type: 'number',
+                        description: '所有步骤共享的目标标签页 ID。步骤自身指定的 tabId 优先级更高',
+                    },
+                },
+                required: ['tabId', 'actions'],
+            },
+        },
+        {
+            name: 'browser_list',
+            description: '列出所有浏览器。返回普通浏览器和托管浏览器的 browserId、名称、类型、连接状态及当前默认目标；托管浏览器还包含运行模式、持久化设置和登录账号。只有 status=connected 的浏览器可用于后续操作。',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        },
+        {
+            name: 'browser_select_browser',
+            description: '选择后续所有浏览器操作的默认目标浏览器（有多个浏览器连接时）。传入 browser_list 返回且 status=connected 的 browserId 或名称即可锁定；传空字符串则清除锁定，回到自动模式（操作最近聚焦的浏览器）。',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    browser: {
+                        type: 'string',
+                        description: '目标浏览器的 browserId / 名称；空字符串表示清除锁定、恢复自动选择',
+                    },
+                },
+                required: ['browser'],
+            },
+        },
+    ];
+    // 处理工具列表请求
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools };
+    });
+    // 处理工具调用请求
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            let result;
+            switch (name) {
+                case 'browser_get_requests': {
+                    const { count = 10, filter, since, includeBody = true, includeHeaders = false, maxBodySize = 50000, fields, keysOnly = false, source, } = args;
+                    result = await client.getRequests({
+                        count,
+                        filter,
+                        since,
+                        includeBody,
+                        includeHeaders,
+                        maxBodySize,
+                        fields,
+                        keysOnly,
+                        source,
+                    });
+                    break;
+                }
+                case 'browser_get_events': {
+                    const { source = 'all', event_type, filter, since, limit = 20 } = args;
+                    result = await client.getEvents({ source, event_type, filter, since, limit });
+                    break;
+                }
+                case 'browser_get_logs': {
+                    const { level = 'all', since, limit = 100, filter } = args;
+                    result = await client.getLogs({ level, since, limit, filter });
+                    break;
+                }
+                case 'browser_set_mock': {
+                    const { payloadFile } = args;
+                    let { apiName, mockData, fields, enabled, duration, conditions } = args;
+                    enabled = enabled ?? true;
+                    // 如果提供了 payloadFile，从文件读取 mock 数据
+                    if (payloadFile) {
+                        if (!existsSync(payloadFile)) {
+                            throw new Error(`Payload file not found: ${payloadFile}`);
+                        }
+                        const fileContent = readFileSync(payloadFile, 'utf-8');
+                        const fileData = JSON.parse(fileContent);
+                        // 文件内容可以包含 apiName、mockData、fields、enabled、duration、conditions 等参数
+                        if (fileData.apiName)
+                            apiName = fileData.apiName;
+                        if (fileData.mockData !== undefined)
+                            mockData = fileData.mockData;
+                        if (fileData.fields !== undefined)
+                            fields = fileData.fields;
+                        if (fileData.enabled !== undefined)
+                            enabled = fileData.enabled;
+                        if (fileData.duration !== undefined)
+                            duration = fileData.duration;
+                        if (fileData.conditions !== undefined)
+                            conditions = fileData.conditions;
+                    }
+                    result = await client.setMock({
+                        apiName,
+                        mockData,
+                        fields,
+                        enabled,
+                        duration,
+                        conditions,
+                    });
+                    break;
+                }
+                case 'browser_get_mocks': {
+                    const { apiName } = args;
+                    result = await client.getMocks({ apiName });
+                    break;
+                }
+                case 'browser_get_api_schema': {
+                    const { api, version = '1.0', fields } = args;
+                    result = await client.getApiSchema({ api, version, fields });
+                    break;
+                }
+                case 'browser_send_request': {
+                    result = await client.sendRequest(args);
+                    break;
+                }
+                case 'browser_send_mtop_request': {
+                    const { api, data, version, method, appKey, env, timeout } = args;
+                    result = await client.sendMtopRequest({
+                        api,
+                        data,
+                        version,
+                        method,
+                        appKey,
+                        env,
+                        timeout,
+                    });
+                    break;
+                }
+                case 'browser_set_rule': {
+                    result = await client.setRule(args);
+                    break;
+                }
+                case 'browser_get_rules': {
+                    result = await client.getRules();
+                    break;
+                }
+                case 'browser_page_screenshot': {
+                    const { format = 'png', quality = 80, selector, tabId } = args;
+                    result = await client.pageScreenshot({ format, quality, selector, tabId });
+                    // 截图工具直接返回 image 类型的 content，符合 MCP 规范
+                    return {
+                        content: [
+                            {
+                                type: 'image',
+                                data: result.data,
+                                mimeType: result.meta.format === 'jpeg' ? 'image/jpeg' : 'image/png',
+                            },
+                            {
+                                type: 'text',
+                                text: `Screenshot captured: ${result.meta.width}x${result.meta.height} ${result.meta.format.toUpperCase()} (${Math.round(result.meta.size / 1024)}KB)\nPage: ${result.meta.title}\nURL: ${result.meta.url}`,
+                            },
+                        ],
+                    };
+                }
+                case 'browser_page_selected_element': {
+                    const { includeOuterHTML = true, includeScreenshot = false, tabId } = args;
+                    result = await client.pageSelectedElement({
+                        includeOuterHTML,
+                        includeScreenshot,
+                        tabId,
+                    });
+                    if (includeScreenshot && result?.screenshot?.data) {
+                        return {
+                            content: [
+                                {
+                                    type: 'image',
+                                    data: result.screenshot.data,
+                                    mimeType: result.screenshot.meta?.format === 'jpeg' ? 'image/jpeg' : 'image/png',
+                                },
+                                {
+                                    type: 'text',
+                                    text: `Selected element screenshot captured: ${result.screenshot.meta?.width}x${result.screenshot.meta?.height} ${String(result.screenshot.meta?.format || '').toUpperCase()}\nElement: ${result.tagName || 'unknown'}\nSelector: ${result.selector || 'N/A'}`,
+                                },
+                            ],
+                        };
+                    }
+                    break;
+                }
+                case 'get_user_info': {
+                    const { detail = false } = args;
+                    result = await client.getUserInfo({ detail });
+                    break;
+                }
+                case 'tdbank_account': {
+                    result = await client.tdbankAccount(args);
+                    break;
+                }
+                case 'browser_launch': {
+                    result = await client.browserLaunch(args);
+                    break;
+                }
+                case 'browser_close': {
+                    result = await client.browserClose(args);
+                    break;
+                }
+                case 'browser_tab_open': {
+                    const { url, active = false, closeExisting = false, reuse = 'never', match, restoreFocusOnClose = false, emulation, group, } = args;
+                    result = await client.tabOpen({
+                        url,
+                        active,
+                        closeExisting,
+                        reuse,
+                        match,
+                        restoreFocusOnClose,
+                        emulation,
+                        group,
+                    });
+                    break;
+                }
+                case 'browser_tab_close': {
+                    const { tabId } = args;
+                    result = await client.tabClose({ tabId });
+                    break;
+                }
+                case 'browser_tab_list': {
+                    result = await client.tabList();
+                    break;
+                }
+                case 'browser_page_click': {
+                    const { tabId, selector, text, point, role, exact, clickType, observe } = args;
+                    result = await client.pageClick({
+                        tabId,
+                        selector,
+                        text,
+                        point,
+                        role,
+                        exact,
+                        clickType,
+                        observe,
+                    });
+                    break;
+                }
+                case 'browser_page_type': {
+                    const { tabId, selector, text, clearFirst = true, observe } = args;
+                    result = await client.pageType({ tabId, selector, text, clearFirst, observe });
+                    break;
+                }
+                case 'browser_page_scroll': {
+                    const { tabId, direction, distance = 600, observe } = args;
+                    result = await client.pageScroll({ tabId, direction, distance, observe });
+                    break;
+                }
+                case 'browser_page_hover': {
+                    const { tabId, selector, observe } = args;
+                    result = await client.pageHover({ tabId, selector, observe });
+                    break;
+                }
+                case 'browser_page_eval': {
+                    const { tabId, expression, frameId, awaitPromise = true } = args;
+                    result = await client.pageEval({ tabId, expression, frameId, awaitPromise });
+                    break;
+                }
+                case 'browser_page_snapshot': {
+                    const { tabId, depth = 15, mode, rootSelector, maxNodes, maxChars } = args;
+                    result = await client.pageSnapshot({
+                        tabId,
+                        depth,
+                        mode,
+                        rootSelector,
+                        maxNodes,
+                        maxChars,
+                    });
+                    break;
+                }
+                case 'browser_page_press': {
+                    const { tabId, key, modifiers, observe } = args;
+                    result = await client.pagePress({ tabId, key, modifiers, observe });
+                    break;
+                }
+                case 'browser_page_wait': {
+                    const { tabId, time, selector, condition, timeout = 10000, interval = 200 } = args;
+                    result = await client.pageWait({
+                        tabId,
+                        time,
+                        selector,
+                        condition,
+                        timeout,
+                        interval,
+                    });
+                    break;
+                }
+                case 'browser_page_navigate': {
+                    const { tabId, url, refresh } = args;
+                    result = await client.pageNavigate({ tabId, url, refresh });
+                    break;
+                }
+                case 'browser_page_upload': {
+                    const { tabId, selector, filePaths, observe } = args;
+                    result = await client.pageUpload({ tabId, selector, filePaths, observe });
+                    break;
+                }
+                case 'browser_page_frames': {
+                    const { tabId } = args;
+                    result = await client.pageFrames({ tabId });
+                    break;
+                }
+                case 'browser_set_device_emulation': {
+                    result = await client.setDeviceEmulation(args);
+                    break;
+                }
+                case 'browser_set_timezone': {
+                    result = await client.setTimezone(args);
+                    break;
+                }
+                case 'browser_run_actions': {
+                    const { actions, tabId } = args;
+                    result = await client.runActions({ actions, tabId });
+                    if (result?.results?.length > 0) {
+                        const screenshots = result.results.filter((r) => r.success && r.action === 'page_screenshot' && r.data?.data);
+                        if (screenshots.length > 0) {
+                            return {
+                                content: [
+                                    ...screenshots.map((r) => ({
+                                        type: 'image',
+                                        data: r.data.data,
+                                        mimeType: r.data.meta?.format === 'jpeg' ? 'image/jpeg' : 'image/png',
+                                    })),
+                                    {
+                                        type: 'text',
+                                        text: JSON.stringify({
+                                            ...result,
+                                            results: result.results.map((r) => r.action === 'page_screenshot' && r.success
+                                                ? { ...r, data: { meta: r.data?.meta } }
+                                                : r),
+                                        }, null, 2),
+                                    },
+                                ],
+                            };
+                        }
+                    }
+                    break;
+                }
+                case 'browser_list': {
+                    result = await client.browserList();
+                    break;
+                }
+                case 'browser_select_browser': {
+                    result = await client.selectBrowser(args);
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+            // 使用智能格式化返回结果
+            return {
+                content: formatResponseWithSizeCheck(result, name, args),
+            };
+        }
+        catch (error) {
+            log(`Error executing tool ${name}:`, error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // 使用 stdio 传输层启动服务器
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    log('MCP Server started and ready');
+}
+// 错误处理
+process.on('uncaughtException', error => {
+    console.error('[MCP Server] Uncaught exception:', error);
+    process.exit(1);
+});
+process.on('unhandledRejection', error => {
+    console.error('[MCP Server] Unhandled rejection:', error);
+    process.exit(1);
+});
+// 启动服务器
+main().catch(error => {
+    console.error('[MCP Server] Failed to start:', error);
+    process.exit(1);
+});