@leeguoo/yapi-mcp 0.1.4

package/dist/server.js

@@ -0,0 +1,847 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YapiMcpServer = void 0;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const express_1 = __importDefault(require("express"));
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const api_1 = require("./services/yapi/api");
+const cache_1 = require("./services/yapi/cache");
+const logger_1 = require("./services/yapi/logger");
+const auth_1 = require("./services/yapi/auth");
+function normalizeJsonArrayInput(value, fieldName) {
+    if (value === undefined || value === null)
+        return { ok: true, value: [] };
+    if (Array.isArray(value))
+        return { ok: true, value };
+    if (typeof value === "string") {
+        try {
+            const parsed = JSON.parse(value);
+            if (!Array.isArray(parsed))
+                return { ok: false, error: `${fieldName} 需要是 JSON 数组` };
+            return { ok: true, value: parsed };
+        }
+        catch (e) {
+            return { ok: false, error: `${fieldName} JSON 解析错误: ${e}` };
+        }
+    }
+    return { ok: false, error: `${fieldName} 需要是 JSON 数组或数组类型` };
+}
+function normalizeStringOrJson(value, fieldName) {
+    if (value === undefined || value === null)
+        return { ok: true, value: "" };
+    if (typeof value === "string")
+        return { ok: true, value };
+    try {
+        return { ok: true, value: JSON.stringify(value, null, 2) };
+    }
+    catch (e) {
+        return { ok: false, error: `${fieldName} 无法序列化为 JSON 字符串: ${e}` };
+    }
+}
+function normalizeTagInput(value) {
+    if (value === undefined || value === null)
+        return { ok: true, value: [] };
+    if (Array.isArray(value))
+        return { ok: true, value: value.map(String).filter(Boolean) };
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return { ok: true, value: [] };
+        if (trimmed.startsWith("[")) {
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (!Array.isArray(parsed))
+                    return { ok: false, error: "tag 需要是 JSON 数组" };
+                return { ok: true, value: parsed.map(String).filter(Boolean) };
+            }
+            catch (e) {
+                return { ok: false, error: `tag JSON 解析错误: ${e}` };
+            }
+        }
+        return { ok: true, value: trimmed.split(/[\s,]+/).map(s => s.trim()).filter(Boolean) };
+    }
+    return { ok: false, error: "tag 需要是字符串或字符串数组" };
+}
+class YapiMcpServer {
+    server;
+    yapiService;
+    projectInfoCache;
+    logger;
+    authService;
+    authMode;
+    sseTransport = null;
+    isStdioMode;
+    constructor(yapiBaseUrl, yapiToken, yapiLogLevel = "info", yapiCacheTTL = 10, auth) {
+        this.logger = new logger_1.Logger("YapiMCP", yapiLogLevel);
+        this.yapiService = new api_1.YApiService(yapiBaseUrl, yapiToken, yapiLogLevel);
+        this.projectInfoCache = new cache_1.ProjectInfoCache(yapiBaseUrl, yapiCacheTTL, yapiLogLevel);
+        this.authMode = auth?.mode ?? (auth?.email && auth?.password ? "global" : "token");
+        this.authService =
+            this.authMode === "global" && auth?.email && auth?.password
+                ? new auth_1.YApiAuthService(yapiBaseUrl, auth.email, auth.password, yapiLogLevel)
+                : null;
+        if (this.authService) {
+            const cachedTokens = this.authService.loadCachedProjectTokens();
+            this.yapiService.setProjectTokens(cachedTokens, { overwrite: false });
+            this.logger.info(`全局模式已启用：已从本地缓存加载 ${cachedTokens.size} 个项目 token`);
+        }
+        this.isStdioMode = process.env.NODE_ENV === "cli" || process.argv.includes("--stdio");
+        this.logger.info(`YapiMcpServer初始化，日志级别: ${yapiLogLevel}, 缓存TTL: ${yapiCacheTTL}分钟`);
+        this.server = new mcp_js_1.McpServer({
+            name: "Yapi MCP Server",
+            version: "0.2.1",
+        });
+        this.registerTools();
+        this.initializeCache();
+    }
+    async initializeCache() {
+        try {
+            if (this.projectInfoCache.isCacheExpired()) {
+                this.logger.info('缓存已过期，将异步更新缓存数据');
+                this.asyncUpdateCache().catch(error => {
+                    this.logger.error('异步更新缓存失败:', error);
+                });
+            }
+            else {
+                const cachedProjectInfo = this.projectInfoCache.loadFromCache();
+                if (cachedProjectInfo.size > 0) {
+                    cachedProjectInfo.forEach((info, id) => {
+                        this.yapiService.getProjectInfoCache().set(id, info);
+                    });
+                    this.logger.info(`已从缓存加载 ${cachedProjectInfo.size} 个项目信息`);
+                }
+                else {
+                    this.logger.info('缓存为空，将异步更新缓存数据');
+                    this.asyncUpdateCache().catch(error => {
+                        this.logger.error('异步更新缓存失败:', error);
+                    });
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error('加载或检查缓存时出错:', error);
+            this.asyncUpdateCache().catch(err => {
+                this.logger.error('异步更新缓存失败:', err);
+            });
+        }
+    }
+    async asyncUpdateCache() {
+        try {
+            this.logger.debug('开始异步更新缓存数据');
+            await this.yapiService.loadAllProjectInfo();
+            this.logger.debug(`已加载 ${this.yapiService.getProjectInfoCache().size} 个项目信息`);
+            this.projectInfoCache.saveToCache(this.yapiService.getProjectInfoCache());
+            await this.yapiService.loadAllCategoryLists();
+            this.logger.debug('已加载所有项目的分类列表');
+            this.logger.info('缓存数据已成功更新');
+        }
+        catch (error) {
+            this.logger.error('更新缓存数据失败:', error);
+            throw error;
+        }
+    }
+    registerTools() {
+        const yapiParamItemSchema = zod_1.z
+            .object({
+            name: zod_1.z.string().describe("参数名"),
+            desc: zod_1.z.string().optional().describe("中文备注/说明（建议把枚举、单位、范围等写清楚）"),
+            type: zod_1.z.string().optional().describe("类型，如 string/number/boolean/integer/object/array"),
+            example: zod_1.z.string().optional().describe("示例值"),
+            required: zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.boolean()]).optional().describe("是否必填（YApi 常用 '1'/'0'）"),
+        })
+            .passthrough();
+        const yapiHeaderItemSchema = yapiParamItemSchema
+            .extend({
+            value: zod_1.z.string().optional().describe("Header 值（如 application/json）"),
+        })
+            .passthrough();
+        const buildInterfaceSaveParams = async (input) => {
+            const isUpdate = Boolean(input.id);
+            let current = null;
+            if (isUpdate) {
+                current = await this.yapiService.getApiInterface(input.projectId, input.id);
+            }
+            const finalCatid = input.catid ?? (current ? String(current.catid ?? "") : "");
+            const finalTitle = input.title ?? (current ? String(current.title ?? "") : "");
+            const finalPath = input.path ?? (current ? String(current.path ?? "") : "");
+            const finalMethod = input.method ?? (current ? String(current.method ?? "") : "");
+            if (!finalCatid)
+                return { ok: false, error: "缺少 catid：新增必填；更新可省略但必须能从原接口读取到" };
+            if (!finalTitle)
+                return { ok: false, error: "缺少 title：新增必填；更新可省略但必须能从原接口读取到" };
+            if (!finalPath)
+                return { ok: false, error: "缺少 path：新增必填；更新可省略但必须能从原接口读取到" };
+            if (!finalMethod)
+                return { ok: false, error: "缺少 method：新增必填；更新可省略但必须能从原接口读取到" };
+            const params = {
+                project_id: input.projectId,
+                catid: finalCatid,
+                title: finalTitle,
+                path: finalPath,
+                method: finalMethod,
+            };
+            if (isUpdate)
+                params.id = input.id;
+            const tagRaw = input.tag !== undefined ? input.tag : isUpdate ? current?.tag : undefined;
+            const tagResult = normalizeTagInput(tagRaw);
+            if (!tagResult.ok)
+                return { ok: false, error: tagResult.error };
+            params.tag = tagResult.value;
+            params.status = input.status ?? (isUpdate ? current?.status : "undone");
+            params.desc = input.desc ?? (isUpdate ? current?.desc : "");
+            params.markdown = input.markdown ?? (isUpdate ? current?.markdown : "");
+            params.message = input.message ?? (isUpdate ? current?.message : "");
+            const reqParamsRaw = input.req_params !== undefined ? input.req_params : isUpdate ? current?.req_params : [];
+            const reqParamsParsed = normalizeJsonArrayInput(reqParamsRaw, "req_params");
+            if (!reqParamsParsed.ok)
+                return { ok: false, error: reqParamsParsed.error };
+            params.req_params = reqParamsParsed.value;
+            const reqQueryRaw = input.req_query !== undefined ? input.req_query : isUpdate ? current?.req_query : [];
+            const reqQueryParsed = normalizeJsonArrayInput(reqQueryRaw, "req_query");
+            if (!reqQueryParsed.ok)
+                return { ok: false, error: reqQueryParsed.error };
+            params.req_query = reqQueryParsed.value;
+            const reqHeadersRaw = input.req_headers !== undefined ? input.req_headers : isUpdate ? current?.req_headers : [];
+            const reqHeadersParsed = normalizeJsonArrayInput(reqHeadersRaw, "req_headers");
+            if (!reqHeadersParsed.ok)
+                return { ok: false, error: reqHeadersParsed.error };
+            params.req_headers = reqHeadersParsed.value;
+            params.req_body_type = input.req_body_type ?? (isUpdate ? current?.req_body_type : "");
+            const reqBodyFormRaw = input.req_body_form !== undefined ? input.req_body_form : isUpdate ? current?.req_body_form : [];
+            const reqBodyFormParsed = normalizeJsonArrayInput(reqBodyFormRaw, "req_body_form");
+            if (!reqBodyFormParsed.ok)
+                return { ok: false, error: reqBodyFormParsed.error };
+            params.req_body_form = reqBodyFormParsed.value;
+            const reqBodyOtherRaw = input.req_body_other !== undefined ? input.req_body_other : isUpdate ? current?.req_body_other : "";
+            const reqBodyOtherNormalized = normalizeStringOrJson(reqBodyOtherRaw, "req_body_other");
+            if (!reqBodyOtherNormalized.ok)
+                return { ok: false, error: reqBodyOtherNormalized.error };
+            params.req_body_other = reqBodyOtherNormalized.value;
+            params.req_body_is_json_schema =
+                input.req_body_is_json_schema ?? (isUpdate ? current?.req_body_is_json_schema : undefined);
+            params.res_body_type = input.res_body_type ?? (isUpdate ? current?.res_body_type : "json");
+            const resBodyRaw = input.res_body !== undefined ? input.res_body : isUpdate ? current?.res_body : "";
+            const resBodyNormalized = normalizeStringOrJson(resBodyRaw, "res_body");
+            if (!resBodyNormalized.ok)
+                return { ok: false, error: resBodyNormalized.error };
+            params.res_body = resBodyNormalized.value;
+            params.res_body_is_json_schema =
+                input.res_body_is_json_schema ?? (isUpdate ? current?.res_body_is_json_schema : undefined);
+            params.switch_notice = input.switch_notice ?? (isUpdate ? current?.switch_notice : undefined);
+            params.api_opened = input.api_opened ?? (isUpdate ? current?.api_opened : undefined);
+            return { ok: true, params, isUpdate };
+        };
+        this.server.tool("yapi_update_token", "全局模式：使用用户名/密码登录 YApi，刷新本地缓存的 projectId -> token（用于后续调用开放 API）", {
+            forceLogin: zod_1.z.boolean().optional().describe("是否强制重新登录（忽略已缓存的 cookie）"),
+        }, async ({ forceLogin }) => {
+            try {
+                if (!this.authService) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "未启用全局模式：请在 MCP 配置中提供 --yapi-auth-mode=global 以及 --yapi-email/--yapi-password（或对应环境变量），然后再调用 yapi_update_token。",
+                            },
+                        ],
+                    };
+                }
+                const { tokens, groups, projects } = await this.authService.refreshProjectTokens({ forceLogin });
+                this.yapiService.setProjectTokens(tokens, { overwrite: true });
+                await this.yapiService.loadAllProjectInfo();
+                this.projectInfoCache.saveToCache(this.yapiService.getProjectInfoCache());
+                await this.yapiService.loadAllCategoryLists();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `token 刷新完成：分组 ${groups.length} 个，项目 ${projects.length} 个，已缓存 token ${tokens.size} 个。`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                this.logger.error("刷新 token 失败:", error);
+                return { content: [{ type: "text", text: `刷新 token 失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_get_api_desc", "获取YApi中特定接口的详细信息", {
+            projectId: zod_1.z.string().describe("YApi项目ID；如连接/project/28/interface/api/66，则ID为28"),
+            apiId: zod_1.z.string().describe("YApi接口的ID；如连接/project/1/interface/api/66，则ID为66")
+        }, async ({ projectId, apiId }) => {
+            try {
+                this.logger.info(`获取API接口: ${apiId}, 项目ID: ${projectId}`);
+                const apiInterface = await this.yapiService.getApiInterface(projectId, apiId);
+                this.logger.info(`成功获取API接口: ${apiInterface.title || apiId}`);
+                const formattedResponse = {
+                    基本信息: {
+                        接口ID: apiInterface._id,
+                        接口名称: apiInterface.title,
+                        接口路径: apiInterface.path,
+                        请求方式: apiInterface.method,
+                        接口描述: apiInterface.desc
+                    },
+                    请求参数: {
+                        URL参数: apiInterface.req_params,
+                        查询参数: apiInterface.req_query,
+                        请求头: apiInterface.req_headers,
+                        请求体类型: apiInterface.req_body_type,
+                        表单参数: apiInterface.req_body_form,
+                        Json参数: apiInterface.req_body_other
+                    },
+                    响应信息: {
+                        响应类型: apiInterface.res_body_type,
+                        响应内容: apiInterface.res_body
+                    },
+                    其他信息: {
+                        接口文档: apiInterface.markdown
+                    },
+                    编辑建议: {
+                        优先更新字段: "req_params / req_query / req_headers / req_body_* / res_body（把枚举值、中文备注、示例尽量放在这些结构字段里）",
+                        避免滥用字段: "desc 只写简要概述；长文档写 markdown；不要用 desc 替代结构化字段",
+                        对应开放API工具: "需要原始字段或精确对应开放 API 时，用 yapi_interface_* / yapi_open_import_data / yapi_project_get"
+                    }
+                };
+                return {
+                    content: [{ type: "text", text: JSON.stringify(formattedResponse, null, 2) }],
+                };
+            }
+            catch (error) {
+                this.logger.error(`获取API接口 ${apiId} 时出错:`, error);
+                return {
+                    content: [{ type: "text", text: `获取API接口出错: ${error}` }],
+                };
+            }
+        });
+        this.server.tool("yapi_project_get", "获取 YApi 项目详情（对应 /api/project/get）", {
+            projectId: zod_1.z.string().describe("YApi项目ID"),
+        }, async ({ projectId }) => {
+            try {
+                const projectInfo = await this.yapiService.getProjectInfo(projectId);
+                return { content: [{ type: "text", text: JSON.stringify(projectInfo, null, 2) }] };
+            }
+            catch (error) {
+                this.logger.error(`获取项目详情失败:`, error);
+                return { content: [{ type: "text", text: `获取项目详情失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_interface_get", "获取接口数据（对应 /api/interface/get，返回原始字段）", {
+            projectId: zod_1.z.string().describe("YApi项目ID（用于选择 token）"),
+            apiId: zod_1.z.string().describe("接口ID"),
+        }, async ({ projectId, apiId }) => {
+            try {
+                const apiInterface = await this.yapiService.getApiInterface(projectId, apiId);
+                return { content: [{ type: "text", text: JSON.stringify(apiInterface, null, 2) }] };
+            }
+            catch (error) {
+                this.logger.error(`获取接口数据失败:`, error);
+                return { content: [{ type: "text", text: `获取接口数据失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_save_api", "新增或更新YApi中的接口信息", {
+            projectId: zod_1.z.string().describe("YApi项目ID"),
+            catid: zod_1.z.string().optional().describe("接口分类ID；新增接口时必填，更新时可省略（会保留原值）"),
+            id: zod_1.z.string().optional().describe("接口ID，更新时必填，新增时不需要"),
+            title: zod_1.z.string().optional().describe("接口标题；新增接口时必填，更新时可省略（会保留原值）"),
+            path: zod_1.z.string().optional().describe("接口路径，如：/api/user；新增接口时必填，更新时可省略（会保留原值）"),
+            method: zod_1.z.string().optional().describe("请求方法，如：GET, POST, PUT, DELETE等；新增接口时必填，更新时可省略（会保留原值）"),
+            status: zod_1.z.string().optional().describe("接口状态，done代表完成，undone代表未完成；更新时可省略（不覆盖原值）"),
+            tag: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional().describe("接口标签列表；支持 JSON 数组字符串或字符串数组；更新时可省略（不覆盖原值）"),
+            req_params: zod_1.z
+                .union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)])
+                .optional()
+                .describe("路径参数；强烈建议填写（枚举值/中文备注放这里）；支持 JSON 数组字符串或数组"),
+            req_query: zod_1.z
+                .union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)])
+                .optional()
+                .describe("查询参数；支持 JSON 数组字符串或数组"),
+            req_headers: zod_1.z
+                .union([zod_1.z.string(), zod_1.z.array(yapiHeaderItemSchema)])
+                .optional()
+                .describe("请求头参数；支持 JSON 数组字符串或数组"),
+            req_body_type: zod_1.z.string().optional().describe("请求体类型（常见：raw/form/json/file）"),
+            req_body_form: zod_1.z
+                .union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)])
+                .optional()
+                .describe("表单请求体；支持 JSON 数组字符串或数组"),
+            req_body_other: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.any()), zod_1.z.array(zod_1.z.any())]).optional().describe("其他请求体（通常是 JSON / JSON Schema）；支持字符串或对象/数组"),
+            req_body_is_json_schema: zod_1.z.boolean().optional().describe("是否开启JSON Schema，默认false"),
+            res_body_type: zod_1.z.string().optional().describe("返回数据类型（常见：json/raw）"),
+            res_body: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.any()), zod_1.z.array(zod_1.z.any())]).optional().describe("返回数据；强烈建议填写（枚举值/中文备注放这里）；支持字符串或对象/数组（会自动序列化）"),
+            res_body_is_json_schema: zod_1.z.boolean().optional().describe("返回数据是否为JSON Schema，默认false"),
+            switch_notice: zod_1.z.boolean().optional().describe("开启接口运行通知，默认true"),
+            api_opened: zod_1.z.boolean().optional().describe("开启API文档页面，默认true"),
+            message: zod_1.z.string().optional().describe("接口备注信息（对应 openapi 示例中的 message 字段）"),
+            desc: zod_1.z.string().optional().describe("接口简要描述（不要把请求/响应结构都塞进 desc；结构请写到 req_* / res_body）"),
+            markdown: zod_1.z.string().optional().describe("markdown格式的接口描述（补充说明/示例；结构仍建议写到 req_* / res_body）")
+        }, async ({ projectId, catid, id, title, path, method, status, tag, req_params, req_query, req_headers, req_body_type, req_body_form, req_body_other, req_body_is_json_schema, res_body_type, res_body, res_body_is_json_schema, switch_notice, api_opened, message, desc, markdown }) => {
+            try {
+                const built = await buildInterfaceSaveParams({
+                    projectId,
+                    catid,
+                    id,
+                    title,
+                    path,
+                    method,
+                    status,
+                    tag,
+                    req_params,
+                    req_query,
+                    req_headers,
+                    req_body_type,
+                    req_body_form,
+                    req_body_other,
+                    req_body_is_json_schema,
+                    res_body_type,
+                    res_body,
+                    res_body_is_json_schema,
+                    switch_notice,
+                    api_opened,
+                    desc,
+                    markdown,
+                    message,
+                });
+                if (!built.ok) {
+                    return { content: [{ type: "text", text: built.error }] };
+                }
+                const response = await this.yapiService.saveInterface(built.params);
+                const resultApiId = response.data._id;
+                return {
+                    content: [{
+                            type: "text",
+                            text: `接口${id ? '更新' : '新增'}成功！\n接口ID: ${resultApiId}\n接口名称: ${built.params.title}\n请求方法: ${built.params.method}\n接口路径: ${built.params.path}`
+                        }],
+                };
+            }
+            catch (error) {
+                this.logger.error(`保存API接口时出错:`, error);
+                return {
+                    content: [{ type: "text", text: `保存API接口出错: ${error}` }],
+                };
+            }
+        });
+        this.server.tool("yapi_interface_add_cat", "新增接口分类（对应 /api/interface/add_cat）", {
+            projectId: zod_1.z.string().describe("YApi项目ID"),
+            name: zod_1.z.string().describe("分类名称"),
+            desc: zod_1.z.string().optional().describe("分类描述"),
+        }, async ({ projectId, name, desc }) => {
+            try {
+                const data = await this.yapiService.addCategory(projectId, name, desc || "");
+                return { content: [{ type: "text", text: `新增分类成功：\n${JSON.stringify(data, null, 2)}` }] };
+            }
+            catch (error) {
+                this.logger.error(`新增接口分类失败:`, error);
+                return { content: [{ type: "text", text: `新增接口分类失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_interface_get_cat_menu", "获取菜单列表（对应 /api/interface/getCatMenu）", {
+            projectId: zod_1.z.string().describe("YApi项目ID"),
+        }, async ({ projectId }) => {
+            try {
+                const list = await this.yapiService.getCategoryList(projectId);
+                return { content: [{ type: "text", text: JSON.stringify(list, null, 2) }] };
+            }
+            catch (error) {
+                this.logger.error(`获取菜单列表失败:`, error);
+                return { content: [{ type: "text", text: `获取菜单列表失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_interface_list", "获取接口列表数据（对应 /api/interface/list）", {
+            projectId: zod_1.z.string().describe("YApi项目ID"),
+            page: zod_1.z.number().optional().describe("页码，默认 1"),
+            limit: zod_1.z.number().optional().describe("每页数量，默认 10"),
+        }, async ({ projectId, page, limit }) => {
+            try {
+                const data = await this.yapiService.listInterfaces(projectId, page ?? 1, limit ?? 10);
+                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+            }
+            catch (error) {
+                this.logger.error(`获取接口列表失败:`, error);
+                return { content: [{ type: "text", text: `获取接口列表失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_interface_list_cat", "获取某个分类下接口列表（对应 /api/interface/list_cat）", {
+            projectId: zod_1.z.string().describe("YApi项目ID"),
+            catId: zod_1.z.string().describe("分类ID"),
+            page: zod_1.z.number().optional().describe("页码，默认 1"),
+            limit: zod_1.z.number().optional().describe("每页数量，默认 10"),
+        }, async ({ projectId, catId, page, limit }) => {
+            try {
+                const response = await this.yapiService.listCategoryInterfaces(projectId, catId, page ?? 1, limit ?? 10);
+                return { content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }] };
+            }
+            catch (error) {
+                this.logger.error(`获取分类接口列表失败:`, error);
+                return { content: [{ type: "text", text: `获取分类接口列表失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_interface_list_menu", "获取接口菜单列表（对应 /api/interface/list_menu）", {
+            projectId: zod_1.z.string().describe("YApi项目ID"),
+        }, async ({ projectId }) => {
+            try {
+                const data = await this.yapiService.getInterfaceMenu(projectId);
+                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+            }
+            catch (error) {
+                this.logger.error(`获取接口菜单列表失败:`, error);
+                return { content: [{ type: "text", text: `获取接口菜单列表失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_interface_add", "新增接口（对应 /api/interface/add）", {
+            projectId: zod_1.z.string().describe("YApi项目ID"),
+            catid: zod_1.z.string().describe("接口分类ID"),
+            title: zod_1.z.string().describe("接口标题"),
+            path: zod_1.z.string().describe("接口路径"),
+            method: zod_1.z.string().describe("请求方法"),
+            status: zod_1.z.string().optional().describe("接口状态，默认 undone"),
+            tag: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional().describe("标签"),
+            req_params: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)]).optional().describe("路径参数"),
+            req_query: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)]).optional().describe("查询参数"),
+            req_headers: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiHeaderItemSchema)]).optional().describe("请求头"),
+            req_body_type: zod_1.z.string().optional().describe("请求体类型"),
+            req_body_form: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)]).optional().describe("表单请求体"),
+            req_body_other: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.any()), zod_1.z.array(zod_1.z.any())]).optional().describe("其他请求体"),
+            req_body_is_json_schema: zod_1.z.boolean().optional().describe("请求体是否 JSON Schema"),
+            res_body_type: zod_1.z.string().optional().describe("响应类型，默认 json"),
+            res_body: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.any()), zod_1.z.array(zod_1.z.any())]).optional().describe("响应内容"),
+            res_body_is_json_schema: zod_1.z.boolean().optional().describe("响应是否 JSON Schema"),
+            switch_notice: zod_1.z.boolean().optional().describe("是否通知"),
+            api_opened: zod_1.z.boolean().optional().describe("是否公开"),
+            message: zod_1.z.string().optional().describe("接口备注信息"),
+            desc: zod_1.z.string().optional().describe("接口描述"),
+            markdown: zod_1.z.string().optional().describe("markdown 描述"),
+        }, async (input) => {
+            try {
+                const built = await buildInterfaceSaveParams({ ...input, id: undefined });
+                if (!built.ok)
+                    return { content: [{ type: "text", text: built.error }] };
+                const response = await this.yapiService.addInterface(built.params);
+                return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
+            }
+            catch (error) {
+                this.logger.error(`新增接口失败:`, error);
+                return { content: [{ type: "text", text: `新增接口失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_interface_up", "更新接口（对应 /api/interface/up）", {
+            projectId: zod_1.z.string().describe("YApi项目ID"),
+            id: zod_1.z.string().describe("接口ID"),
+            catid: zod_1.z.string().optional().describe("分类ID（可省略，会保留原值）"),
+            title: zod_1.z.string().optional().describe("接口标题（可省略，会保留原值）"),
+            path: zod_1.z.string().optional().describe("接口路径（可省略，会保留原值）"),
+            method: zod_1.z.string().optional().describe("请求方法（可省略，会保留原值）"),
+            status: zod_1.z.string().optional().describe("接口状态"),
+            tag: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional().describe("标签"),
+            req_params: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)]).optional().describe("路径参数"),
+            req_query: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)]).optional().describe("查询参数"),
+            req_headers: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiHeaderItemSchema)]).optional().describe("请求头"),
+            req_body_type: zod_1.z.string().optional().describe("请求体类型"),
+            req_body_form: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)]).optional().describe("表单请求体"),
+            req_body_other: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.any()), zod_1.z.array(zod_1.z.any())]).optional().describe("其他请求体"),
+            req_body_is_json_schema: zod_1.z.boolean().optional().describe("请求体是否 JSON Schema"),
+            res_body_type: zod_1.z.string().optional().describe("响应类型"),
+            res_body: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.any()), zod_1.z.array(zod_1.z.any())]).optional().describe("响应内容"),
+            res_body_is_json_schema: zod_1.z.boolean().optional().describe("响应是否 JSON Schema"),
+            switch_notice: zod_1.z.boolean().optional().describe("是否通知"),
+            api_opened: zod_1.z.boolean().optional().describe("是否公开"),
+            message: zod_1.z.string().optional().describe("接口备注信息"),
+            desc: zod_1.z.string().optional().describe("接口描述"),
+            markdown: zod_1.z.string().optional().describe("markdown 描述"),
+        }, async (input) => {
+            try {
+                const built = await buildInterfaceSaveParams(input);
+                if (!built.ok)
+                    return { content: [{ type: "text", text: built.error }] };
+                const response = await this.yapiService.updateInterface(built.params);
+                return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
+            }
+            catch (error) {
+                this.logger.error(`更新接口失败:`, error);
+                return { content: [{ type: "text", text: `更新接口失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_interface_save", "新增或者更新接口（对应 /api/interface/save）", {
+            projectId: zod_1.z.string().describe("YApi项目ID"),
+            id: zod_1.z.string().optional().describe("接口ID（有则更新，无则新增）"),
+            catid: zod_1.z.string().optional().describe("接口分类ID"),
+            title: zod_1.z.string().optional().describe("接口标题"),
+            path: zod_1.z.string().optional().describe("接口路径"),
+            method: zod_1.z.string().optional().describe("请求方法"),
+            status: zod_1.z.string().optional().describe("接口状态"),
+            tag: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional().describe("标签"),
+            req_params: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)]).optional().describe("路径参数"),
+            req_query: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)]).optional().describe("查询参数"),
+            req_headers: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiHeaderItemSchema)]).optional().describe("请求头"),
+            req_body_type: zod_1.z.string().optional().describe("请求体类型"),
+            req_body_form: zod_1.z.union([zod_1.z.string(), zod_1.z.array(yapiParamItemSchema)]).optional().describe("表单请求体"),
+            req_body_other: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.any()), zod_1.z.array(zod_1.z.any())]).optional().describe("其他请求体"),
+            req_body_is_json_schema: zod_1.z.boolean().optional().describe("请求体是否 JSON Schema"),
+            res_body_type: zod_1.z.string().optional().describe("响应类型"),
+            res_body: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.any()), zod_1.z.array(zod_1.z.any())]).optional().describe("响应内容"),
+            res_body_is_json_schema: zod_1.z.boolean().optional().describe("响应是否 JSON Schema"),
+            switch_notice: zod_1.z.boolean().optional().describe("是否通知"),
+            api_opened: zod_1.z.boolean().optional().describe("是否公开"),
+            message: zod_1.z.string().optional().describe("接口备注信息"),
+            desc: zod_1.z.string().optional().describe("接口描述"),
+            markdown: zod_1.z.string().optional().describe("markdown 描述"),
+        }, async (input) => {
+            try {
+                const built = await buildInterfaceSaveParams(input);
+                if (!built.ok)
+                    return { content: [{ type: "text", text: built.error }] };
+                const response = await this.yapiService.saveInterfaceUnified(built.params);
+                return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
+            }
+            catch (error) {
+                this.logger.error(`保存接口失败:`, error);
+                return { content: [{ type: "text", text: `保存接口失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_open_import_data", "服务端数据导入（对应 /api/open/import_data）", {
+            projectId: zod_1.z.string().describe("YApi项目ID（用于选择 token）"),
+            type: zod_1.z.string().describe("导入方式，如 swagger"),
+            merge: zod_1.z.enum(["normal", "good", "merge"]).describe("同步模式：normal/good/merge"),
+            json: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.any()), zod_1.z.array(zod_1.z.any())]).optional().describe("导入数据 JSON（会自动序列化为字符串）"),
+            url: zod_1.z.string().optional().describe("导入数据 URL（提供后会走 url 方式）"),
+        }, async ({ projectId, type, merge, json, url }) => {
+            try {
+                let jsonString;
+                if (json !== undefined) {
+                    const normalized = normalizeStringOrJson(json, "json");
+                    if (!normalized.ok)
+                        return { content: [{ type: "text", text: normalized.error }] };
+                    jsonString = normalized.value;
+                }
+                const data = await this.yapiService.importData(projectId, { type, merge, json: jsonString, url });
+                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+            }
+            catch (error) {
+                this.logger.error(`导入数据失败:`, error);
+                return { content: [{ type: "text", text: `导入数据失败: ${error}` }] };
+            }
+        });
+        this.server.tool("yapi_search_apis", "搜索YApi中的接口", {
+            projectKeyword: zod_1.z.string().optional().describe("项目关键字，用于过滤项目"),
+            nameKeyword: zod_1.z.string().optional().describe("接口名称关键字"),
+            pathKeyword: zod_1.z.string().optional().describe("接口路径关键字"),
+            tagKeyword: zod_1.z.string().optional().describe("接口标签关键字"),
+            limit: zod_1.z.number().optional().describe("返回结果数量限制，默认20")
+        }, async ({ projectKeyword, nameKeyword, pathKeyword, tagKeyword, limit }) => {
+            try {
+                const searchOptions = {
+                    projectKeyword,
+                    nameKeyword: nameKeyword ? nameKeyword.split(/[\s,]+/) : undefined,
+                    pathKeyword: pathKeyword ? pathKeyword.split(/[\s,]+/) : undefined,
+                    tagKeyword: tagKeyword ? tagKeyword.split(/[\s,]+/) : undefined,
+                    limit: limit || 20
+                };
+                this.logger.info(`搜索API接口: ${JSON.stringify(searchOptions)}`);
+                const searchResults = await this.yapiService.searchApis(searchOptions);
+                const apisByProject = {};
+                searchResults.list.forEach(api => {
+                    const projectId = String(api.project_id);
+                    const projectName = api.project_name || `未知项目(${projectId})`;
+                    if (!apisByProject[projectId]) {
+                        apisByProject[projectId] = {
+                            projectName,
+                            apis: []
+                        };
+                    }
+                    apisByProject[projectId].apis.push({
+                        id: api._id,
+                        title: api.title,
+                        path: api.path,
+                        method: api.method,
+                        catName: api.cat_name || '未知分类',
+                        createTime: new Date(api.add_time).toLocaleString(),
+                        updateTime: new Date(api.up_time).toLocaleString()
+                    });
+                });
+                let responseContent = `共找到 ${searchResults.total} 个符合条件的接口（已限制显示 ${searchResults.list.length} 个）\n\n`;
+                responseContent += "搜索条件:\n";
+                if (projectKeyword)
+                    responseContent += `- 项目关键字: ${projectKeyword}\n`;
+                if (nameKeyword)
+                    responseContent += `- 接口名称关键字: ${nameKeyword}\n`;
+                if (pathKeyword)
+                    responseContent += `- API路径关键字: ${pathKeyword}\n`;
+                if (tagKeyword)
+                    responseContent += `- 标签关键字: ${tagKeyword}\n\n`;
+                Object.values(apisByProject).forEach(projectGroup => {
+                    responseContent += `## 项目: ${projectGroup.projectName} (${projectGroup.apis.length}个接口)\n\n`;
+                    if (projectGroup.apis.length <= 10) {
+                        projectGroup.apis.forEach(api => {
+                            responseContent += `### ${api.title} (${api.method} ${api.path})\n\n`;
+                            responseContent += `- 接口ID: ${api.id}\n`;
+                            responseContent += `- 所属分类: ${api.catName}\n`;
+                            responseContent += `- 更新时间: ${api.updateTime}\n\n`;
+                        });
+                    }
+                    else {
+                        responseContent += "| 接口ID | 接口名称 | 请求方式 | 接口路径 | 所属分类 |\n";
+                        responseContent += "| ------ | -------- | -------- | -------- | -------- |\n";
+                        projectGroup.apis.forEach(api => {
+                            responseContent += `| ${api.id} | ${api.title} | ${api.method} | ${api.path} | ${api.catName} |\n`;
+                        });
+                        responseContent += "\n";
+                    }
+                });
+                responseContent += "\n提示: 可以使用 `get_api_desc` 工具获取接口的详细信息，例如: `get_api_desc projectId=228 apiId=8570`";
+                return {
+                    content: [{ type: "text", text: responseContent }],
+                };
+            }
+            catch (error) {
+                this.logger.error(`搜索接口时出错:`, error);
+                let errorMsg = "搜索接口时发生错误";
+                if (error instanceof Error) {
+                    errorMsg += `: ${error.message}`;
+                }
+                else if (typeof error === 'object' && error !== null) {
+                    errorMsg += `: ${JSON.stringify(error)}`;
+                }
+                return {
+                    content: [{ type: "text", text: errorMsg }],
+                };
+            }
+        });
+        this.server.tool("yapi_list_projects", "列出YApi的项目ID(projectId)和项目名称", {}, async () => {
+            try {
+                const projectInfoCache = this.yapiService.getProjectInfoCache();
+                if (projectInfoCache.size === 0) {
+                    return {
+                        content: [{ type: "text", text: "没有找到任何项目信息，请检查配置的token是否正确" }],
+                    };
+                }
+                const projectsList = Array.from(projectInfoCache.entries()).map(([id, info]) => ({
+                    项目ID: id,
+                    项目名称: info.name,
+                    项目描述: info.desc || '无描述',
+                    基础路径: info.basepath || '/',
+                    项目分组ID: info.group_id
+                }));
+                return {
+                    content: [{
+                            type: "text",
+                            text: `已配置 ${projectInfoCache.size} 个YApi项目:\n\n${JSON.stringify(projectsList, null, 2)}`
+                        }],
+                };
+            }
+            catch (error) {
+                this.logger.error(`获取项目信息列表时出错:`, error);
+                return {
+                    content: [{ type: "text", text: `获取项目信息列表出错: ${error}` }],
+                };
+            }
+        });
+        this.server.tool("yapi_get_categories", "获取YApi项目下的接口分类列表，以及每个分类下的接口信息", {
+            projectId: zod_1.z.string().describe("YApi项目ID"),
+            includeApis: zod_1.z.boolean().optional().describe("是否包含分类下接口列表，默认 true"),
+            limitPerCategory: zod_1.z.number().optional().describe("每个分类最多返回多少接口（默认 100）")
+        }, async ({ projectId, includeApis, limitPerCategory }) => {
+            try {
+                const shouldIncludeApis = includeApis ?? true;
+                const perCatLimit = limitPerCategory ?? 100;
+                const projectInfo = await this.yapiService.getProjectInfo(projectId);
+                const categoryList = await this.yapiService.getCategoryList(projectId);
+                if (!categoryList || categoryList.length === 0) {
+                    return {
+                        content: [{ type: "text", text: `项目 "${projectInfo.name}" (ID: ${projectId}) 下没有找到任何接口分类` }],
+                    };
+                }
+                if (!shouldIncludeApis) {
+                    const simplified = categoryList.map(cat => ({
+                        分类ID: cat._id,
+                        分类名称: cat.name,
+                        分类描述: cat.desc || "无描述",
+                        创建时间: new Date(cat.add_time).toLocaleString(),
+                        更新时间: new Date(cat.up_time).toLocaleString(),
+                    }));
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `项目 "${projectInfo.name}" (ID: ${projectId}) 下共有 ${categoryList.length} 个接口分类:\n\n${JSON.stringify(simplified, null, 2)}`,
+                            },
+                        ],
+                    };
+                }
+                const categoriesWithApisPromises = categoryList.map(async (cat) => {
+                    try {
+                        const apisResponse = await this.yapiService.listCategoryInterfaces(projectId, cat._id, 1, perCatLimit);
+                        const apis = apisResponse.data.list;
+                        const simplifiedApis = apis?.map(api => ({
+                            接口ID: api._id,
+                            接口名称: api.title,
+                            接口路径: api.path,
+                            请求方法: api.method
+                        })) || [];
+                        return {
+                            分类ID: cat._id,
+                            分类名称: cat.name,
+                            分类描述: cat.desc || '无描述',
+                            创建时间: new Date(cat.add_time).toLocaleString(),
+                            更新时间: new Date(cat.up_time).toLocaleString(),
+                            接口列表: simplifiedApis
+                        };
+                    }
+                    catch (error) {
+                        this.logger.error(`获取分类 ${cat._id} 下的接口列表失败:`, error);
+                        return {
+                            分类ID: cat._id,
+                            分类名称: cat.name,
+                            分类描述: cat.desc || '无描述',
+                            创建时间: new Date(cat.add_time).toLocaleString(),
+                            更新时间: new Date(cat.up_time).toLocaleString(),
+                            接口列表: [],
+                            错误: `获取接口列表失败: ${error}`
+                        };
+                    }
+                });
+                const categoriesWithApis = await Promise.all(categoriesWithApisPromises);
+                return {
+                    content: [{
+                            type: "text",
+                            text: `项目 "${projectInfo.name}" (ID: ${projectId}) 下共有 ${categoryList.length} 个接口分类:\n\n${JSON.stringify(categoriesWithApis, null, 2)}`
+                        }],
+                };
+            }
+            catch (error) {
+                this.logger.error(`获取接口分类列表时出错:`, error);
+                return {
+                    content: [{ type: "text", text: `获取接口分类列表出错: ${error}` }],
+                };
+            }
+        });
+    }
+    async connect(transport) {
+        this.logger.info("连接到传输层...");
+        await this.server.connect(transport);
+        this.logger.info("服务器已连接，准备处理请求");
+    }
+    async startHttpServer(port) {
+        const app = (0, express_1.default)();
+        app.get("/sse", async (req, res) => {
+            this.logger.info("建立新的SSE连接");
+            this.sseTransport = new sse_js_1.SSEServerTransport("/messages", res);
+            await this.server.connect(this.sseTransport);
+        });
+        app.post("/messages", async (req, res) => {
+            if (!this.sseTransport) {
+                res.sendStatus(400);
+                return;
+            }
+            await this.sseTransport.handlePostMessage(req, res);
+        });
+        app.listen(port, () => {
+            this.logger.info(`HTTP服务器监听端口 ${port}`);
+            this.logger.info(`SSE端点: http://localhost:${port}/sse`);
+            this.logger.info(`消息端点: http://localhost:${port}/messages`);
+        });
+    }
+}
+exports.YapiMcpServer = YapiMcpServer;
+//# sourceMappingURL=server.js.map