@wukongcrm/mcp-server 0.2.3 → 0.2.4

package/README.md

@@ -147,7 +147,7 @@ npm pack
 生成文件示例：
 
 ```text
-wukongcrm-mcp-server-0.2.3.tgz
+wukongcrm-mcp-server-0.2.4.tgz
 ```
 
 这个包只包含运行所需的 `dist`、`README.md` 和 `package.json`，不会携带源码、测试文件或用户 API Key。
@@ -155,7 +155,7 @@ wukongcrm-mcp-server-0.2.3.tgz
 使用者拿到 `.tgz` 后安装：
 
 ```powershell
-npm install -g .\wukongcrm-mcp-server-0.2.3.tgz
+npm install -g .\wukongcrm-mcp-server-0.2.4.tgz
 ```
 
 安装后可以直接用命令启动：
@@ -189,7 +189,7 @@ wukong-mcp
 无代码工具只调用源码中声明的固定接口，不提供任意 URL 透传。写工具保持既有 MCP 语义：未传 `confirm=true` 时返回将要调用的接口、请求体和查询参数；明确确认后才执行。
 
 - 应用与模块：`nocode_list_applications`、`nocode_get_application`、`nocode_list_modules`、`nocode_get_module`、`nocode_write_application`、`nocode_write_module`
-- 字段与数据：`nocode_get_module_schema`、`nocode_query_fields`、`nocode_search_records`、`nocode_get_record`、`nocode_query_records`、`nocode_calculate_formula`、`nocode_check_duplicate`、`nocode_write_field`、`nocode_write_record`
+- 字段与数据：`nocode_get_module_schema`、`nocode_query_fields`、`nocode_search_records`、`nocode_get_record`、`nocode_query_records`、`nocode_calculate_formula`、`nocode_check_duplicate`、`nocode_write_field`、`nocode_replace_field_with_relation`、`nocode_write_record`
 - 权限与团队：`nocode_list_team_members`、`nocode_get_permissions`、`nocode_write_team`、`nocode_write_role`
 - 场景与页面：`nocode_list_scenes`、`nocode_list_tabs`、`nocode_get_module_file`、`nocode_write_scene`、`nocode_write_tab`
 - 流程与阶段：`nocode_list_flows`、`nocode_list_stages`、`nocode_list_custom_buttons`、`nocode_query_workflow`、`nocode_write_flow`、`nocode_write_stage`、`nocode_write_custom_button`、`nocode_write_workflow`
@@ -201,8 +201,10 @@ wukong-mcp
 常见保存动作必须使用旧前端对应的聚合 BO，而不是把单个字段或单个值直接作为 `payload`：
 
 - 字段保存：`ModuleFieldSaveBO`，至少包含 `moduleId`、实际 `version`、`mainFieldId`/`tempMainFieldId` 和非空 `moduleFieldList`。
+- 普通字段改为数据关联：优先使用 `nocode_replace_field_with_relation`。它会按 `baseVersion` 读取完整字段聚合，阻断主字段、明细字段、已有关系、非空数据和删除依赖，保存草稿后再回读验证；不会自动发布。
 - 记录保存：`ModuleFieldDataSaveBO`，至少包含 `moduleId`、实际 `version` 和非空 `fieldDataList`；字段值使用 `fieldId`、`fieldName`、`name`、`type`、`value`，修改时增加 `dataId`。
 - 新建模块的实际版本通常从 `0` 开始，应先用 `nocode_get_module` 读取并显式传入，不能根据已发布老模块猜测为 `1`。
+- 发布模块时，`nocode_write_module(action=publish)` 必须显式传入预览确认过的最新草稿 `version`；旧后端发布接口虽不接收版本，MCP 会在调用前校验版本并在调用后校验激活状态。
 
 文件流仍有意不经 MCP 代理，因此应用导入/导出、Excel 导入/导出、跟进导出、打印 PDF/Word 下载不在工具中；打印内容生成和预览 JSON 接口仍可使用。内部测试接口 `/moduleMQ/send` 也不会暴露。
 

package/dist/nocode.js

@@ -246,7 +246,7 @@ export const nocodeToolDefinitions = [
     },
     {
         name: "nocode_write_module",
-        description: "保存、启停、复制、发布、丢弃草稿、删除模块、保存页面布局或维护 BI Dashboard 模块；action=save 的 payload 使用旧 CRM ModuleSaveBO（常见普通模块包含 applicationId、name、moduleType=1、icon）；必须 confirm=true。",
+        description: "保存、启停、复制、发布、丢弃草稿、删除模块、保存页面布局或维护 BI Dashboard 模块；action=save 的 payload 使用旧 CRM ModuleSaveBO（常见普通模块包含 applicationId、name、moduleType=1、icon）；action=publish 必须显式传 version，工具会锁定当前最新草稿版本；必须 confirm=true。",
         schema: z.object({
             action: z.enum(["save", "status", "copy", "publish", "discardDraft", "delete", "layout", "deleteCancelledCompanyData", "dashboardSave", "dashboardRemove"]),
             moduleId: idSchema.optional(),
@@ -265,6 +265,21 @@ export const nocodeToolDefinitions = [
         access: "write",
         destructive: true
     },
+    {
+        name: "nocode_replace_field_with_relation",
+        description: "把无代码模块中的一个顶层普通自定义字段语义化替换为单选数据关联字段。工具会校验模块版本、主字段/明细/关联字段限制、当前账号可见数据、字段删除依赖和目标已发布状态；默认只预览，confirm=true 后保存为草稿并回读验证，不自动发布。",
+        schema: z.object({
+            moduleId: idSchema,
+            baseVersion: z.number().int().nonnegative(),
+            sourceFieldId: idSchema,
+            relationFieldName: z.string().trim().min(1, "关联字段名称不能为空。"),
+            targetModuleId: idSchema,
+            required: z.boolean().optional(),
+            confirm: confirmSchema
+        }),
+        access: "write",
+        destructive: true
+    },
     {
         name: "nocode_write_record",
         description: "新增/修改、删除、转移负责人或设置分组；action=save 的 payload 必须是 ModuleFieldDataSaveBO，包含 moduleId、实际 version、fieldDataList；每个字段值应包含 fieldId、fieldName、name、type、value，修改时再带 dataId；必须 confirm=true，否则只返回预览。",
@@ -542,6 +557,7 @@ export function createNocodeToolHandlers(config = {}, sharedClient) {
             fixedSort: "/moduleField/fixed/setFieldSort",
             fixedStyle: "/moduleField/fixed/setFieldStyle"
         }),
+        nocode_replace_field_with_relation: async (args) => executeRelationFieldReplacement(client, args),
         nocode_write_record: async (args) => executeRecordWrite(client, args, {
             save: "/moduleFieldData/save",
             delete: "/moduleFieldData/delete",
@@ -954,6 +970,9 @@ async function executeApplicationWrite(client, args) {
 }
 async function executeModuleWrite(client, args) {
     const action = String(args.action);
+    if (action === "publish") {
+        return publishModuleDraft(client, args);
+    }
     let targetPath;
     let body;
     let query;
@@ -969,9 +988,6 @@ async function executeModuleWrite(client, args) {
         case "copy":
             targetPath = `/moduleM/copy/${requiredId(args.moduleId, "moduleId")}/${requiredVersion(args.version)}`;
             break;
-        case "publish":
-            targetPath = `/moduleM/active/${requiredId(args.moduleId, "moduleId")}`;
-            break;
         case "discardDraft":
             targetPath = `/moduleM/discardDraft/${requiredId(args.moduleId, "moduleId")}`;
             break;
@@ -999,6 +1015,270 @@ async function executeModuleWrite(client, args) {
     }
     return confirmedPost(client, args, action, targetPath, body, query);
 }
+async function publishModuleDraft(client, args) {
+    const moduleId = requiredId(args.moduleId, "moduleId");
+    const version = requiredExplicitVersion(args.version, "version");
+    const targetPath = `/moduleM/active/${moduleId}`;
+    const latest = requiredObject(await client.post(`/moduleM/queryById/${moduleId}`, undefined, { isLatest: true }), "无法读取待发布模块的最新版本。");
+    const latestVersion = requiredExplicitVersion(latest.version, "latest.version");
+    // 发布接口本身不接收版本号；必须在调用前锁定调用方确认过的草稿版本，避免误发新草稿。
+    if (latestVersion !== version) {
+        throw new Error(`模块版本已变化：请求发布 version=${version}，当前最新 version=${latestVersion}。请重新预览。`);
+    }
+    if (latest.isActive !== false || Number(latest.status) !== 2) {
+        throw new Error(`version=${version} 不是可发布草稿，已拒绝调用无版本参数的发布接口。`);
+    }
+    if (args.confirm !== true) {
+        return {
+            preview: true,
+            message: "发布前预览：已锁定当前最新草稿版本；未传 confirm=true，不会调用发布接口。",
+            action: "publish",
+            targetPath,
+            version,
+            preflight: { latestVersion, status: latest.status, isActive: latest.isActive }
+        };
+    }
+    const published = requiredObject(await client.post(targetPath), "发布接口未返回模块信息，无法确认发布结果。");
+    const publishedVersion = requiredExplicitVersion(published.version, "published.version");
+    const verified = publishedVersion === version && published.isActive === true && Number(published.status) === 1;
+    return {
+        preview: false,
+        action: "publish",
+        targetPath,
+        version,
+        verified,
+        publishReady: verified,
+        message: verified ? "草稿已按确认版本发布，并完成返回值校验。" : "发布接口已调用，但返回值未通过版本/激活状态校验。",
+        data: published
+    };
+}
+async function executeRelationFieldReplacement(client, args) {
+    const moduleId = requiredId(args.moduleId, "moduleId");
+    const sourceFieldId = requiredId(args.sourceFieldId, "sourceFieldId");
+    const targetModuleId = requiredId(args.targetModuleId, "targetModuleId");
+    const baseVersion = requiredExplicitVersion(args.baseVersion, "baseVersion");
+    const relationFieldName = requiredText(args.relationFieldName, "relationFieldName");
+    const moduleDetail = requiredObject(await client.post(`/moduleM/queryById/${moduleId}`, undefined, { isLatest: true }), "无法读取来源模块的最新版本。");
+    const latestVersion = requiredExplicitVersion(moduleDetail.version, "module.version");
+    if (latestVersion !== baseVersion) {
+        throw new Error(`模块版本已变化：baseVersion=${baseVersion}，当前最新 version=${latestVersion}。请重新读取结构后再替换。`);
+    }
+    const moduleStatus = Number(moduleDetail.status);
+    if (![1, 2].includes(moduleStatus)
+        || (moduleStatus === 1 && moduleDetail.isActive !== true)
+        || (moduleStatus === 2 && moduleDetail.isActive === true)) {
+        throw new Error("来源模块不是可编辑的已发布版本或草稿版本，已拒绝字段替换。");
+    }
+    const mainFieldId = requiredId(moduleDetail.mainFieldId, "module.mainFieldId");
+    const fields = requiredObjectArray(await client.post("/moduleField/queryList", { moduleId: numericValue(moduleId), version: baseVersion }), "模块字段列表");
+    const sourceField = fields.find((field) => sameId(field.fieldId, sourceFieldId));
+    if (!sourceField) {
+        throw new Error(`sourceFieldId=${sourceFieldId} 不在模块 ${moduleId} 的 version=${baseVersion} 字段列表中。`);
+    }
+    // 该动作只负责“普通字段 -> 新建单选数据关联”；现有关系改目标会触发旧后端的非版本化关系配置风险。
+    if (sameId(sourceFieldId, mainFieldId)) {
+        throw new Error("主字段不能被语义化替换。请保留主字段并选择其他普通自定义字段。");
+    }
+    if (Number(sourceField.fieldType) !== 1) {
+        throw new Error("仅支持替换 fieldType=1 的自定义字段，系统字段不会被删除。");
+    }
+    if (sourceField.groupId !== undefined && sourceField.groupId !== null) {
+        throw new Error("明细表格内字段不能被此工具替换；仅支持顶层普通字段。");
+    }
+    // 布局、计算、唯一编号、树和关系字段都有额外配置，不能按普通值字段的删除语义处理。
+    if ([45, 49, 50, 51, 53, 56, 60, 63, 67, 68, 76, 81, 82, 83, 84, 100, 110].includes(Number(sourceField.type))) {
+        throw new Error("布局、计算、配置或已有关系字段不能作为替换来源；请选择顶层普通值字段。");
+    }
+    if ([1, 3].includes(Number(sourceField.operating))) {
+        throw new Error("该字段的 operating 配置不允许删除，已拒绝替换。");
+    }
+    if (fields.some((field) => !sameId(field.fieldId, sourceFieldId) && String(field.name ?? "").trim() === relationFieldName)) {
+        throw new Error(`模块中已存在名为“${relationFieldName}”的其他字段。`);
+    }
+    if (fields.some((field) => Number(field.type) === 68)) {
+        throw new Error("模块包含树字段；旧后端查询结果缺少聚合保存所需的临时展示字段 ID，已保守阻断替换。");
+    }
+    const defaultValueConfigs = requiredObjectArray(await client.post(`/moduleFieldDefault/list/${moduleId}/${baseVersion}`), "字段默认值配置");
+    const fieldStatisticConfigs = requiredObjectArray(await client.post(`/moduleFieldStatistic/query/${moduleId}/${baseVersion}`), "字段统计配置");
+    // /moduleField/save 会先清空再重建这两类配置；语义工具没有完整编辑上下文时宁可拒绝，也不能静默擦除。
+    if (defaultValueConfigs.length > 0 || fieldStatisticConfigs.length > 0) {
+        throw new Error(`模块包含 ${defaultValueConfigs.length} 条字段默认值配置和 ${fieldStatisticConfigs.length} 条字段统计配置，已保守阻断替换。`);
+    }
+    const sourceFieldName = requiredText(sourceField.fieldName, "sourceField.fieldName");
+    const sourceFormType = requiredText(sourceField.formType, "sourceField.formType");
+    const sourceDataQuery = {
+        page: 1,
+        limit: 1,
+        searchList: [{
+                fieldId: numericValue(sourceFieldId),
+                fieldName: sourceFieldName,
+                formType: sourceFormType,
+                type: 6,
+                values: [],
+                groupId: 0
+            }]
+    };
+    const sourceDataPage = await client.post(`/moduleData/queryPageList/${moduleId}`, sourceDataQuery);
+    if (pageHasRows(sourceDataPage)) {
+        throw new Error(`字段“${String(sourceField.name ?? sourceFieldName)}”存在非空数据，替换会在发布时丢失原值，已阻断。`);
+    }
+    const deleteImpact = requiredObject(await client.post("/moduleField/checkFieldDelete", {
+        moduleId: numericValue(moduleId),
+        fieldId: numericValue(sourceFieldId),
+        fieldName: sourceFieldName,
+        version: baseVersion
+    }), "字段删除依赖检查未返回有效结果。");
+    const dependentFields = requiredArray(deleteImpact.moduleFields, "deleteImpact.moduleFields");
+    const dependentFlows = requiredArray(deleteImpact.moduleFlows, "deleteImpact.moduleFlows");
+    if (dependentFields.length > 0 || dependentFlows.length > 0) {
+        throw new Error(`字段仍被 ${dependentFields.length} 个字段配置和 ${dependentFlows.length} 个流程配置引用，已阻断替换。`);
+    }
+    const targetModule = requiredObject(await client.post(`/moduleM/queryById/${targetModuleId}`, undefined, { isLatest: false }), "无法读取关联目标模块的已发布版本。");
+    if (targetModule.isActive !== true || Number(targetModule.status) !== 1) {
+        throw new Error("关联目标模块必须存在已发布激活版本。");
+    }
+    const requiredRelation = args.required === undefined ? Number(sourceField.isNull) === 1 : args.required === true;
+    const retainedFields = fields
+        .filter((field) => !sameId(field.fieldId, sourceFieldId))
+        .map((field) => ({
+        ...field,
+        tempFieldId: `existing-${requiredId(field.fieldId, "field.fieldId")}`
+    }));
+    const mainTempFieldId = `existing-${mainFieldId}`;
+    if (!retainedFields.some((field) => field.tempFieldId === mainTempFieldId)) {
+        throw new Error("字段聚合中未找到主字段，拒绝提交可能破坏主字段的保存请求。");
+    }
+    const replacementField = cleanObject({
+        tempFieldId: `relation-${sourceFieldId}-${targetModuleId}`,
+        name: relationFieldName,
+        type: 100,
+        fieldType: 1,
+        isNull: requiredRelation ? 1 : 0,
+        isHidden: 0,
+        formPosition: sourceField.formPosition,
+        stylePercent: sourceField.stylePercent,
+        optionsData: {
+            type: 1,
+            targetName: "module",
+            targetId: numericValue(targetModuleId)
+        }
+    });
+    const sourceIndex = fields.findIndex((field) => sameId(field.fieldId, sourceFieldId));
+    const moduleFieldList = [...retainedFields];
+    // 旧后端以数组下标重写 sorting；插回来源位置才能保持其他字段与表单的既有顺序。
+    moduleFieldList.splice(sourceIndex, 0, replacementField);
+    const saveBody = {
+        moduleId: numericValue(moduleId),
+        version: baseVersion,
+        mainFieldId: numericValue(mainFieldId),
+        tempMainFieldId: mainTempFieldId,
+        moduleFieldList
+    };
+    const preflight = {
+        latestVersion,
+        sourceDataEmpty: true,
+        dataQueryScope: "当前 MCP 账号可见数据（旧后端强制数据权限过滤）",
+        defaultValueConfigCount: 0,
+        fieldStatisticConfigCount: 0,
+        dependentFieldCount: 0,
+        dependentFlowCount: 0,
+        targetModule: {
+            moduleId: targetModuleId,
+            version: targetModule.version,
+            name: targetModule.name,
+            isActive: targetModule.isActive
+        }
+    };
+    if (args.confirm !== true) {
+        return {
+            preview: true,
+            message: "字段替换前预览：安全校验已通过；未传 confirm=true，不会保存字段草稿。",
+            action: "replaceFieldWithRelation",
+            targetPath: "/moduleField/save",
+            moduleId,
+            baseVersion,
+            sourceField: fieldSummary(sourceField),
+            replacementField,
+            preflight,
+            body: saveBody
+        };
+    }
+    const savedModule = requiredObject(await client.post("/moduleField/save", saveBody), "字段保存接口未返回模块信息，无法回读验证。");
+    const savedVersion = requiredExplicitVersion(savedModule.version, "savedModule.version");
+    const expectedSavedVersion = moduleDetail.isActive === true ? baseVersion + 1 : baseVersion;
+    const readbackFields = requiredObjectArray(await client.post("/moduleField/queryList", { moduleId: numericValue(moduleId), version: savedVersion }), "保存后字段列表");
+    const retainedFieldIds = retainedFields.map((field) => requiredId(field.fieldId, "retainedField.fieldId"));
+    const replacementMatches = readbackFields.filter((field) => {
+        const optionsData = isObject(field.optionsData) ? field.optionsData : {};
+        return String(field.name ?? "").trim() === relationFieldName
+            && Number(field.type) === 100
+            && Number(field.fieldType) === 1
+            && Number(optionsData.type) === 1
+            && optionsData.targetName === "module"
+            && sameId(optionsData.targetId, targetModuleId);
+    });
+    const verificationErrors = [];
+    if (savedVersion !== expectedSavedVersion) {
+        verificationErrors.push(`保存版本应为 ${expectedSavedVersion}，实际为 ${savedVersion}`);
+    }
+    if (Number(savedModule.status) !== 2 || savedModule.isActive !== false) {
+        verificationErrors.push("保存结果不是未激活草稿");
+    }
+    if (readbackFields.some((field) => sameId(field.fieldId, sourceFieldId))) {
+        verificationErrors.push("来源字段仍存在");
+    }
+    if (replacementMatches.length !== 1) {
+        verificationErrors.push(`匹配的新关联字段数量为 ${replacementMatches.length}`);
+    }
+    else {
+        if (Number(replacementMatches[0].isNull) !== (requiredRelation ? 1 : 0)) {
+            verificationErrors.push("新关联字段必填属性不一致");
+        }
+        if (readbackFields.indexOf(replacementMatches[0]) !== sourceIndex) {
+            verificationErrors.push("新关联字段未保留来源字段位置");
+        }
+        if (sourceField.formPosition !== undefined
+            && sourceField.formPosition !== null
+            && replacementMatches[0].formPosition !== sourceField.formPosition) {
+            verificationErrors.push("新关联字段表单位置不一致");
+        }
+    }
+    const missingRetainedIds = retainedFieldIds.filter((fieldId) => !readbackFields.some((field) => sameId(field.fieldId, fieldId)));
+    if (missingRetainedIds.length > 0) {
+        verificationErrors.push(`缺少 ${missingRetainedIds.length} 个应保留字段`);
+    }
+    if (!sameId(savedModule.mainFieldId, mainFieldId)) {
+        verificationErrors.push("主字段 ID 发生变化");
+    }
+    if (readbackFields.length !== fields.length) {
+        verificationErrors.push(`字段总数应为 ${fields.length}，实际为 ${readbackFields.length}`);
+    }
+    const verified = verificationErrors.length === 0;
+    const replacement = replacementMatches[0];
+    return {
+        preview: false,
+        action: "replaceFieldWithRelation",
+        targetPath: "/moduleField/save",
+        moduleId,
+        baseVersion,
+        savedVersion,
+        saved: true,
+        verified,
+        publishReady: verified,
+        message: verified
+            ? "字段已替换为单选数据关联并保存为草稿，回读验证通过；仍需显式发布该 savedVersion。"
+            : "字段草稿已保存，但回读验证未通过；请检查草稿，不要发布。",
+        preflight,
+        verification: {
+            errors: verificationErrors,
+            sourceRemoved: !readbackFields.some((field) => sameId(field.fieldId, sourceFieldId)),
+            retainedFieldsPresent: missingRetainedIds.length === 0,
+            replacementFieldId: replacement?.fieldId,
+            replacementTargetModuleId: targetModuleId
+        },
+        data: savedModule
+    };
+}
 async function executePayloadWrite(client, args, paths) {
     const action = String(args.action);
     const targetPath = paths[action];
@@ -1116,6 +1396,16 @@ function requiredVersion(value) {
     }
     return normalized;
 }
+function requiredExplicitVersion(value, field) {
+    if (value === undefined || value === null || value === "") {
+        throw new Error(`${field} 必须显式传入非负整数。`);
+    }
+    const normalized = Number(value);
+    if (!Number.isInteger(normalized) || normalized < 0) {
+        throw new Error(`${field} 必须是非负整数。`);
+    }
+    return normalized;
+}
 function requiredInteger(value, field) {
     const normalized = Number(value);
     if (!Number.isInteger(normalized)) {
@@ -1148,6 +1438,64 @@ function safePayload(value) {
     }
     return value;
 }
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function requiredObject(value, message) {
+    if (!isObject(value)) {
+        throw new Error(message);
+    }
+    return value;
+}
+function requiredArray(value, field) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${field} 必须是数组；无法完成安全校验。`);
+    }
+    return value;
+}
+function requiredObjectArray(value, field) {
+    return requiredArray(value, field).map((item, index) => requiredObject(item, `${field}[${index}] 不是有效对象。`));
+}
+function requiredText(value, field) {
+    const normalized = typeof value === "string" ? value.trim() : "";
+    if (!normalized) {
+        throw new Error(`${field} 不能为空。`);
+    }
+    return normalized;
+}
+function sameId(value, expected) {
+    return value !== undefined && value !== null && String(value).trim() === expected;
+}
+function pageHasRows(value) {
+    const page = requiredObject(value, "字段存量数据检查未返回有效分页结果，已保守阻断。");
+    const rows = Array.isArray(page.list) ? page.list : undefined;
+    if (rows && rows.length > 0) {
+        return true;
+    }
+    if (page.totalRow !== undefined && page.totalRow !== null) {
+        const totalRow = Number(page.totalRow);
+        if (!Number.isInteger(totalRow) || totalRow < 0) {
+            throw new Error("字段存量数据检查返回了无效 totalRow，已保守阻断。");
+        }
+        return totalRow > 0;
+    }
+    if (rows) {
+        return false;
+    }
+    throw new Error("字段存量数据检查既没有 list 也没有 totalRow，已保守阻断。");
+}
+function fieldSummary(field) {
+    return cleanObject({
+        fieldId: field.fieldId,
+        fieldName: field.fieldName,
+        name: field.name,
+        type: field.type,
+        formType: field.formType,
+        isNull: field.isNull,
+        formPosition: field.formPosition,
+        stylePercent: field.stylePercent
+    });
+}
 function applicationPayload(value, action) {
     const payload = safePayload(value);
     const name = typeof payload.name === "string" ? payload.name.trim() : "";

package/dist/server.js

@@ -192,7 +192,7 @@ export function createWukongMcpServer(config = {}) {
     const { oauth, ...crmConfig } = config;
     const server = new McpServer({
         name: "wukong-mcp",
-        version: "0.2.3"
+        version: "0.2.4"
     }, {
         instructions: "先使用只读工具确认模块、记录和字段，再执行写入。所有写入必须显式传 confirm=true；不要尝试任意 URL 请求。"
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wukongcrm/mcp-server",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Local and remote MCP server for fixed 72CRM API access.",
   "type": "module",
   "main": "./dist/index.js",