weixin-devtools-mcp 0.0.1

package/build/server.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+/**
+ * 微信开发者工具自动化 MCP 服务器 (模块化版本)
+ * 基于 chrome-devtools-mcp 架构模式重构
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { allTools, SimpleToolResponse } from './tools/index.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+/**
+ * 全局上下文状态
+ */
+const globalContext = {
+    miniProgram: null,
+    currentPage: null,
+    elementMap: new Map(),
+    consoleStorage: {
+        consoleMessages: [],
+        exceptionMessages: [],
+        isMonitoring: false,
+        startTime: null,
+    },
+    networkStorage: {
+        requests: [],
+        isMonitoring: false,
+        startTime: null,
+        originalMethods: {},
+    },
+};
+/**
+ * 创建 MCP 服务器
+ */
+const server = new Server({
+    name: "weixin-devtools-mcp",
+    version: "0.3.3",
+}, {
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+/**
+ * 工具处理器映射
+ */
+const toolHandlers = new Map();
+/**
+ * 注册工具到 MCP 服务器
+ */
+function registerTool(tool) {
+    toolHandlers.set(tool.name, tool);
+}
+/**
+ * 处理资源列表请求
+ */
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    const resources = [];
+    // 连接状态资源
+    resources.push({
+        uri: "weixin://connection/status",
+        mimeType: "application/json",
+        name: "连接状态",
+        description: "微信开发者工具连接状态"
+    });
+    // 如果已连接，提供页面快照资源
+    if (globalContext.miniProgram && globalContext.currentPage) {
+        resources.push({
+            uri: "weixin://page/snapshot",
+            mimeType: "application/json",
+            name: "页面快照",
+            description: "当前页面的元素快照"
+        });
+    }
+    return { resources };
+});
+/**
+ * 处理资源读取请求
+ */
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const url = new URL(request.params.uri);
+    if (url.pathname === "/connection/status") {
+        const status = {
+            connected: !!globalContext.miniProgram,
+            hasCurrentPage: !!globalContext.currentPage,
+            pagePath: globalContext.currentPage ? await globalContext.currentPage.path : null,
+            elementCount: globalContext.elementMap.size
+        };
+        return {
+            contents: [{
+                    uri: request.params.uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify(status, null, 2)
+                }]
+        };
+    }
+    if (url.pathname === "/page/snapshot") {
+        if (!globalContext.currentPage) {
+            throw new Error("当前没有活动页面");
+        }
+        try {
+            // 这里可以实现获取页面快照的逻辑
+            const snapshot = {
+                path: await globalContext.currentPage.path,
+                elementCount: globalContext.elementMap.size,
+                timestamp: new Date().toISOString()
+            };
+            return {
+                contents: [{
+                        uri: request.params.uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify(snapshot, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            throw new Error(`获取页面快照失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    throw new Error(`未知的资源: ${request.params.uri}`);
+});
+/**
+ * 处理工具列表请求
+ */
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = allTools.map(tool => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: zodToJsonSchema(tool.schema, {
+            strictUnions: true
+        }),
+        annotations: tool.annotations
+    }));
+    return { tools };
+});
+/**
+ * 处理工具调用请求
+ */
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    const tool = toolHandlers.get(toolName);
+    if (!tool) {
+        throw new Error(`未知的工具: ${toolName}`);
+    }
+    try {
+        // 验证参数
+        const validatedParams = tool.schema.parse(request.params.arguments || {});
+        // 创建工具请求和响应对象
+        const toolRequest = { params: validatedParams };
+        const toolResponse = new SimpleToolResponse();
+        // 执行工具处理器
+        await tool.handler(toolRequest, toolResponse, globalContext);
+        // 构建响应内容
+        const content = [];
+        // 添加文本响应
+        const responseText = toolResponse.getResponseText();
+        if (responseText) {
+            content.push({
+                type: "text",
+                text: responseText
+            });
+        }
+        // 添加附加的图片
+        const attachedImages = toolResponse.getAttachedImages();
+        for (const image of attachedImages) {
+            content.push({
+                type: "image",
+                data: image.data,
+                mimeType: image.mimeType
+            });
+        }
+        return { content };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{
+                    type: "text",
+                    text: `工具执行失败: ${errorMessage}`
+                }],
+            isError: true
+        };
+    }
+});
+/**
+ * 注册所有工具
+ */
+for (const tool of allTools) {
+    registerTool(tool);
+}
+/**
+ * 启动服务器
+ */
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/build/tools/ToolDefinition.js

@@ -0,0 +1,52 @@
+/**
+ * 工具定义基础框架
+ * 参考 chrome-devtools-mcp 的设计模式
+ */
+/**
+ * 工具分类枚举
+ */
+export var ToolCategories;
+(function (ToolCategories) {
+    ToolCategories["CONNECTION"] = "Connection";
+    ToolCategories["PAGE_INTERACTION"] = "Page interaction";
+    ToolCategories["AUTOMATION"] = "Automation";
+    ToolCategories["DEBUGGING"] = "Debugging";
+})(ToolCategories || (ToolCategories = {}));
+/**
+ * 定义工具的辅助函数
+ */
+export function defineTool(definition) {
+    return {
+        name: definition.name,
+        description: definition.description,
+        schema: definition.schema,
+        annotations: definition.annotations,
+        handler: definition.handler,
+    };
+}
+/**
+ * 简单的响应实现类
+ */
+export class SimpleToolResponse {
+    responseLines = [];
+    includeSnapshot = false;
+    attachedImages = [];
+    appendResponseLine(text) {
+        this.responseLines.push(text);
+    }
+    setIncludeSnapshot(include) {
+        this.includeSnapshot = include;
+    }
+    attachImage(data, mimeType) {
+        this.attachedImages.push({ data, mimeType });
+    }
+    getResponseText() {
+        return this.responseLines.join('\n');
+    }
+    shouldIncludeSnapshot() {
+        return this.includeSnapshot;
+    }
+    getAttachedImages() {
+        return this.attachedImages;
+    }
+}

package/build/tools/assert.js

@@ -0,0 +1,245 @@
+/**
+ * 断言验证工具
+ * 提供各种元素状态和内容的断言验证功能
+ */
+import { z } from 'zod';
+import { defineTool } from './ToolDefinition.js';
+import { assertElementExists, assertElementVisible, assertElementText, assertElementAttribute } from '../tools.js';
+/**
+ * 断言元素存在
+ */
+export const assertExistsTool = defineTool({
+    name: 'assert_exists',
+    description: '断言元素存在或不存在',
+    schema: z.object({
+        selector: z.string().optional().describe('CSS选择器'),
+        uid: z.string().optional().describe('元素UID'),
+        shouldExist: z.boolean().describe('期望存在状态，true为存在，false为不存在'),
+        timeout: z.number().optional().default(5000).describe('等待超时时间(毫秒)，默认5000ms'),
+    }),
+    annotations: {
+        audience: ['developers'],
+    },
+    handler: async (request, response, context) => {
+        const { selector, uid, shouldExist, timeout } = request.params;
+        if (!selector && !uid) {
+            throw new Error('必须提供selector或uid参数');
+        }
+        if (!context.currentPage) {
+            throw new Error('请先获取当前页面');
+        }
+        try {
+            const options = {
+                selector,
+                uid,
+                shouldExist,
+                timeout
+            };
+            const result = await assertElementExists(context.currentPage, options);
+            // 根据断言结果返回信息
+            response.appendResponseLine(`断言结果: ${result.passed ? '通过' : '失败'}`);
+            response.appendResponseLine(`消息: ${result.message}`);
+            response.appendResponseLine(`期望: ${result.expected}`);
+            response.appendResponseLine(`实际: ${result.actual}`);
+            response.appendResponseLine(`时间戳: ${new Date(result.timestamp).toISOString()}`);
+            if (!result.passed) {
+                throw new Error(`断言失败: ${result.message}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            response.appendResponseLine(`断言执行失败: ${errorMessage}`);
+            throw error;
+        }
+    },
+});
+/**
+ * 断言元素可见性
+ */
+export const assertVisibleTool = defineTool({
+    name: 'assert_visible',
+    description: '断言元素可见或不可见',
+    schema: z.object({
+        uid: z.string().describe('元素UID'),
+        visible: z.boolean().describe('期望可见状态，true为可见，false为不可见'),
+    }),
+    annotations: {
+        audience: ['developers'],
+    },
+    handler: async (request, response, context) => {
+        const { uid, visible } = request.params;
+        if (!context.currentPage) {
+            throw new Error('请先获取当前页面');
+        }
+        try {
+            const options = { uid, visible };
+            const result = await assertElementVisible(context.currentPage, context.elementMap, options);
+            // 根据断言结果返回信息
+            response.appendResponseLine(`断言结果: ${result.passed ? '通过' : '失败'}`);
+            response.appendResponseLine(`消息: ${result.message}`);
+            response.appendResponseLine(`期望: ${result.expected ? '可见' : '不可见'}`);
+            response.appendResponseLine(`实际: ${result.actual ? '可见' : '不可见'}`);
+            response.appendResponseLine(`时间戳: ${new Date(result.timestamp).toISOString()}`);
+            if (!result.passed) {
+                throw new Error(`断言失败: ${result.message}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            response.appendResponseLine(`断言执行失败: ${errorMessage}`);
+            throw error;
+        }
+    },
+});
+/**
+ * 断言元素文本内容
+ */
+export const assertTextTool = defineTool({
+    name: 'assert_text',
+    description: '断言元素文本内容',
+    schema: z.object({
+        uid: z.string().describe('元素UID'),
+        text: z.string().optional().describe('精确匹配的文本'),
+        textContains: z.string().optional().describe('包含的文本'),
+        textMatches: z.string().optional().describe('正则表达式匹配'),
+    }),
+    annotations: {
+        audience: ['developers'],
+    },
+    handler: async (request, response, context) => {
+        const { uid, text, textContains, textMatches } = request.params;
+        if (!text && !textContains && !textMatches) {
+            throw new Error('必须指定text、textContains或textMatches参数之一');
+        }
+        if (!context.currentPage) {
+            throw new Error('请先获取当前页面');
+        }
+        try {
+            const options = {
+                uid,
+                text,
+                textContains,
+                textMatches
+            };
+            const result = await assertElementText(context.currentPage, context.elementMap, options);
+            // 根据断言结果返回信息
+            response.appendResponseLine(`断言结果: ${result.passed ? '通过' : '失败'}`);
+            response.appendResponseLine(`消息: ${result.message}`);
+            response.appendResponseLine(`期望: ${result.expected}`);
+            response.appendResponseLine(`实际: ${result.actual}`);
+            response.appendResponseLine(`时间戳: ${new Date(result.timestamp).toISOString()}`);
+            if (!result.passed) {
+                throw new Error(`断言失败: ${result.message}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            response.appendResponseLine(`断言执行失败: ${errorMessage}`);
+            throw error;
+        }
+    },
+});
+/**
+ * 断言元素属性
+ */
+export const assertAttributeTool = defineTool({
+    name: 'assert_attribute',
+    description: '断言元素属性值',
+    schema: z.object({
+        uid: z.string().describe('元素UID'),
+        attributeKey: z.string().describe('属性名'),
+        attributeValue: z.string().describe('期望的属性值'),
+    }),
+    annotations: {
+        audience: ['developers'],
+    },
+    handler: async (request, response, context) => {
+        const { uid, attributeKey, attributeValue } = request.params;
+        if (!context.currentPage) {
+            throw new Error('请先获取当前页面');
+        }
+        try {
+            const options = {
+                uid,
+                attribute: {
+                    key: attributeKey,
+                    value: attributeValue
+                }
+            };
+            const result = await assertElementAttribute(context.currentPage, context.elementMap, options);
+            // 根据断言结果返回信息
+            response.appendResponseLine(`断言结果: ${result.passed ? '通过' : '失败'}`);
+            response.appendResponseLine(`消息: ${result.message}`);
+            response.appendResponseLine(`期望: ${result.expected}`);
+            response.appendResponseLine(`实际: ${result.actual}`);
+            response.appendResponseLine(`时间戳: ${new Date(result.timestamp).toISOString()}`);
+            if (!result.passed) {
+                throw new Error(`断言失败: ${result.message}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            response.appendResponseLine(`断言执行失败: ${errorMessage}`);
+            throw error;
+        }
+    },
+});
+/**
+ * 断言元素状态（通用）
+ */
+export const assertStateTool = defineTool({
+    name: 'assert_state',
+    description: '断言元素的各种状态',
+    schema: z.object({
+        uid: z.string().describe('元素UID'),
+        visible: z.boolean().optional().describe('期望可见状态'),
+        enabled: z.boolean().optional().describe('期望启用状态'),
+        checked: z.boolean().optional().describe('期望选中状态（checkbox/radio）'),
+        focused: z.boolean().optional().describe('期望焦点状态'),
+    }),
+    annotations: {
+        audience: ['developers'],
+    },
+    handler: async (request, response, context) => {
+        const { uid, visible, enabled, checked, focused } = request.params;
+        if (visible === undefined && enabled === undefined && checked === undefined && focused === undefined) {
+            throw new Error('必须指定至少一个状态参数');
+        }
+        if (!context.currentPage) {
+            throw new Error('请先获取当前页面');
+        }
+        try {
+            const results = [];
+            // 可见性断言
+            if (visible !== undefined) {
+                const options = { uid, visible };
+                const result = await assertElementVisible(context.currentPage, context.elementMap, options);
+                results.push(result);
+            }
+            // TODO: 这里可以添加更多状态断言，如enabled、checked、focused
+            // 目前只实现了visible，其他状态需要扩展底层函数
+            // 汇总结果
+            const allPassed = results.every(r => r.passed);
+            const failedResults = results.filter(r => !r.passed);
+            response.appendResponseLine(`断言结果: ${allPassed ? '全部通过' : '部分失败'}`);
+            response.appendResponseLine(`检查项数: ${results.length}`);
+            response.appendResponseLine(`通过项数: ${results.filter(r => r.passed).length}`);
+            response.appendResponseLine(`失败项数: ${failedResults.length}`);
+            if (failedResults.length > 0) {
+                response.appendResponseLine('');
+                response.appendResponseLine('失败详情:');
+                failedResults.forEach((result, index) => {
+                    response.appendResponseLine(`${index + 1}. ${result.message}`);
+                });
+            }
+            if (!allPassed) {
+                throw new Error(`状态断言失败: ${failedResults.length}/${results.length} 项失败`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            response.appendResponseLine(`断言执行失败: ${errorMessage}`);
+            throw error;
+        }
+    },
+});