@wukongcrm/mcp-server 0.1.4 → 0.2.0

package/dist/nocode.js

@@ -0,0 +1,1086 @@
+import { z } from "zod";
+import { CrmClient } from "./client.js";
+const idSchema = z.union([z.string(), z.number()]);
+const payloadSchema = z.record(z.unknown());
+const confirmSchema = z.boolean().optional();
+const versionSchema = z.number().int().nonnegative().optional();
+const moduleContextShape = {
+    moduleId: idSchema,
+    version: versionSchema,
+    categoryId: idSchema.optional()
+};
+const payloadWriteShape = {
+    payload: payloadSchema,
+    confirm: confirmSchema
+};
+const extendedContextShape = {
+    applicationId: idSchema.optional(),
+    moduleId: idSchema.optional(),
+    targetModuleId: idSchema.optional(),
+    dataId: idSchema.optional(),
+    tabId: idSchema.optional(),
+    stageId: idSchema.optional(),
+    followUpId: idSchema.optional(),
+    recordId: idSchema.optional(),
+    commentId: idSchema.optional(),
+    ruleId: idSchema.optional(),
+    noticeId: idSchema.optional(),
+    categoryId: idSchema.optional(),
+    typeId: idSchema.optional(),
+    id: idSchema.optional(),
+    ids: z.array(idSchema).optional(),
+    version: versionSchema,
+    type: z.number().int().optional(),
+    language: z.string().optional(),
+    replaceMask: z.boolean().optional(),
+    payload: payloadSchema.optional()
+};
+export const nocodeToolDefinitions = [
+    {
+        name: "nocode_list_applications",
+        description: "查询当前旧 CRM 用户可访问的无代码应用列表；只读。",
+        schema: z.object({}).optional(),
+        access: "read"
+    },
+    {
+        name: "nocode_get_application",
+        description: "按 applicationId 查询旧 CRM 无代码应用详情；只读。",
+        schema: z.object({ applicationId: idSchema }),
+        access: "read"
+    },
+    {
+        name: "nocode_list_modules",
+        description: "查询无代码应用下的模块；mode 可选 latest、released、all 或 bi，默认 released；只读。",
+        schema: z.object({ applicationId: idSchema, mode: z.enum(["latest", "released", "all", "bi"]).optional() }),
+        access: "read"
+    },
+    {
+        name: "nocode_get_module",
+        description: "查询无代码模块详情；传 version 获取指定版本，否则通过 isLatest 获取最新或已发布版本；只读。",
+        schema: z.object({ moduleId: idSchema, version: versionSchema, isLatest: z.boolean().optional() }),
+        access: "read"
+    },
+    {
+        name: "nocode_get_module_schema",
+        description: "一次获取无代码模块字段、表单布局、列表头、页面布局、选项、公式、标签和序列号规则；写入记录前应先调用；只读。",
+        schema: z.object({ ...moduleContextShape, includeExtended: z.boolean().optional() }),
+        access: "read"
+    },
+    {
+        name: "nocode_search_records",
+        description: "按 moduleId 查询无代码模块记录列表；payload 使用旧 CRM ModuleSearchBO 条件，服务端强制启用数据权限过滤；只读。",
+        schema: z.object({ moduleId: idSchema, page: z.number().int().positive().optional(), limit: z.number().int().positive().max(200).optional(), payload: payloadSchema.optional() }),
+        access: "read"
+    },
+    {
+        name: "nocode_get_record",
+        description: "按 dataId 查询无代码记录及动态字段值；replaceMask 默认 true，继续执行字段脱敏；只读。",
+        schema: z.object({ dataId: idSchema, replaceMask: z.boolean().optional() }),
+        access: "read"
+    },
+    {
+        name: "nocode_calculate_formula",
+        description: "根据无代码记录字段 payload 计算公式字段但不保存；只读计算。",
+        schema: z.object({ payload: payloadSchema }),
+        access: "read"
+    },
+    {
+        name: "nocode_check_duplicate",
+        description: "调用无代码字段值验重规则，不修改数据；只读。",
+        schema: z.object({ payload: payloadSchema }),
+        access: "read"
+    },
+    {
+        name: "nocode_list_team_members",
+        description: "查询指定无代码记录的团队成员及当前用户团队权限；只读。",
+        schema: z.object({ moduleId: idSchema, dataId: idSchema }),
+        access: "read"
+    },
+    {
+        name: "nocode_get_permissions",
+        description: "查询无代码权限；kind 支持当前权限总览、应用角色、数据权限、字段权限、角色字段权限；只读。",
+        schema: z.object({
+            kind: z.enum(["auth", "roles", "rolesByIds", "usersRoles", "viewableUserIds", "data", "field", "roleField"]),
+            applicationId: idSchema.optional(),
+            moduleId: idSchema.optional(),
+            dataId: idSchema.optional(),
+            userId: idSchema.optional(),
+            ids: z.array(idSchema).optional(),
+            payload: payloadSchema.optional()
+        }),
+        access: "read"
+    },
+    {
+        name: "nocode_list_scenes",
+        description: "查询无代码模块的场景筛选配置；只读。",
+        schema: z.object({ moduleId: idSchema }),
+        access: "read"
+    },
+    {
+        name: "nocode_list_flows",
+        description: "查询无代码模块的流程配置；参数按旧 CRM FlowQueryBO 传入；只读。",
+        schema: z.object({ payload: payloadSchema }),
+        access: "read"
+    },
+    {
+        name: "nocode_list_stages",
+        description: "查询无代码模块版本或指定记录的阶段配置；只读。",
+        schema: z.object({ moduleId: idSchema.optional(), version: versionSchema, dataId: idSchema.optional() }),
+        access: "read"
+    },
+    {
+        name: "nocode_list_custom_buttons",
+        description: "查询无代码模块版本的自定义按钮配置；只读。",
+        schema: z.object({ moduleId: idSchema, version: z.number().int().nonnegative() }),
+        access: "read"
+    },
+    {
+        name: "nocode_list_tabs",
+        description: "查询无代码模块的自定义详情页 Tab 配置；只读。",
+        schema: z.object({ moduleId: idSchema }),
+        access: "read"
+    },
+    {
+        name: "nocode_get_module_file",
+        description: "查询无代码模块文件元数据；不下载文件流；只读。",
+        schema: z.object({ payload: payloadSchema }),
+        access: "read"
+    },
+    {
+        name: "nocode_query_fields",
+        description: "查询无代码字段的导出表头、固定表头、校验、删除影响、关联字段、默认值、树形数据和统计配置/结果；只读。",
+        schema: z.object({
+            operation: z.enum(["exportHead", "fixedListHead", "verify", "checkDelete", "union", "dashboardHead", "dashboardModule", "defaultList", "defaultValues", "defaultFiltered", "defaultFormula", "treeConfig", "treeData", "statisticConfig", "statisticValues", "statisticUnion"]),
+            ...extendedContextShape
+        }),
+        access: "read"
+    },
+    {
+        name: "nocode_query_records",
+        description: "查询指定 ID 记录、原始字段值、主字段、字段统计、操作记录、自定义按钮处理记录和 Tab 绑定数据；只读。",
+        schema: z.object({
+            operation: z.enum(["byDataIds", "raw", "mainField", "mainFields", "mainFieldData", "fieldStatistic", "operationRecords", "customButtonDealRecords", "tabBoundDataIds"]),
+            ...extendedContextShape
+        }),
+        access: "read"
+    },
+    {
+        name: "nocode_query_workflow",
+        description: "查询流程预览/详情/处理详情、审批记录、待处理记录、阶段字段/数据/评论；只读。",
+        schema: z.object({
+            operation: z.enum(["preview", "flowDetail", "dealDetail", "examineRecord", "dealRecords", "stageFields", "stageForm", "stageData", "stageComments"]),
+            ...extendedContextShape
+        }),
+        access: "read"
+    },
+    {
+        name: "nocode_query_followups",
+        description: "查询无代码跟进配置字段/表单、跟进配置、跟进数据列表、跟进记录列表及评论；只读，不导出文件流。",
+        schema: z.object({
+            operation: z.enum(["fieldList", "fieldForm", "availableForm", "configList", "dataPage", "recordPage", "comments"]),
+            ...extendedContextShape
+        }),
+        access: "read"
+    },
+    {
+        name: "nocode_query_configuration",
+        description: "查询无代码自定义分类/提醒、数据校验规则、用户搜索配置、外部字段映射和多语言配置；只读。",
+        schema: z.object({
+            operation: z.enum(["scene", "customCategoryConfig", "customCategories", "customNotice", "dataCheckRules", "dataCheck", "userSearch", "externalFieldMappings", "languageModule", "languageApplication", "languageCurrent"]),
+            ...extendedContextShape
+        }),
+        access: "read"
+    },
+    {
+        name: "nocode_query_printing",
+        description: "查询无代码打印模板字段、模板列表/详情和打印记录；只读。打印、预览和模板变更请使用 nocode_write_printing。",
+        schema: z.object({
+            operation: z.enum(["fields", "templates", "template", "records", "record"]),
+            ...extendedContextShape
+        }),
+        access: "read"
+    },
+    {
+        name: "nocode_query_messages",
+        description: "查询旧 CRM 无代码消息、应用消息及数据导入进度/结果；只读。",
+        schema: z.object({
+            operation: z.enum(["summary", "page", "moduleType", "importProgress", "importInfo"]),
+            messageId: idSchema.optional(),
+            ...extendedContextShape
+        }),
+        access: "read"
+    },
+    {
+        name: "nocode_query_integrations",
+        description: "查询外部应用/模块、模块开放配置以及开放模块数据；固定白名单，只读。",
+        schema: z.object({
+            operation: z.enum(["externalApplications", "externalModules", "externalModule", "moduleByExternalId", "openModules", "openApplication", "openConfig", "openRecords", "openRecord", "openBoundDataIds"]),
+            externalModuleId: idSchema.optional(),
+            configType: z.number().int().optional(),
+            ...extendedContextShape
+        }),
+        access: "read"
+    },
+    {
+        name: "nocode_query_marketplace",
+        description: "查询无代码应用模板管理企业、系统分类/应用、发布状态和当前企业应用分类；只读。",
+        schema: z.object({ operation: z.enum(["manageCompany", "systemCategories", "systemApps", "publishStatus", "appCategories"]) }),
+        access: "read"
+    },
+    {
+        name: "nocode_write_application",
+        description: "新增、修改、启停、删除、排序或安装无代码应用；必须 confirm=true，否则只返回固定接口和请求预览。",
+        schema: z.object({
+            action: z.enum(["create", "update", "status", "delete", "sort", "install"]),
+            applicationId: idSchema.optional(),
+            status: z.number().int().optional(),
+            ids: z.array(idSchema).optional(),
+            payload: payloadSchema.optional(),
+            confirm: confirmSchema
+        }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_module",
+        description: "保存、启停、复制、发布、丢弃草稿、删除模块、保存页面布局或维护 BI Dashboard 模块；必须 confirm=true。",
+        schema: z.object({
+            action: z.enum(["save", "status", "copy", "publish", "discardDraft", "delete", "layout", "deleteCancelledCompanyData", "dashboardSave", "dashboardRemove"]),
+            moduleId: idSchema.optional(),
+            version: versionSchema,
+            isEnable: z.boolean().optional(),
+            payload: payloadSchema.optional(),
+            confirm: confirmSchema
+        }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_field",
+        description: "保存字段，或修改普通/固定模块列表字段排序和样式；必须 confirm=true，否则只返回固定接口和请求预览。",
+        schema: z.object({ action: z.enum(["save", "sort", "style", "fixedSort", "fixedStyle"]), ...payloadWriteShape }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_record",
+        description: "新增/修改、删除、转移负责人或设置分组；payload 使用对应旧 CRM BO；必须 confirm=true，否则只返回预览。",
+        schema: z.object({ action: z.enum(["save", "delete", "transfer", "setCategory"]), ...payloadWriteShape }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_team",
+        description: "新增或移除无代码记录团队成员；必须 confirm=true，否则只返回预览。",
+        schema: z.object({ action: z.enum(["save", "remove"]), ...payloadWriteShape }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_scene",
+        description: "新增、修改、删除、设为默认或保存场景配置；必须 confirm=true，否则只返回预览。",
+        schema: z.object({ action: z.enum(["add", "update", "delete", "default", "config"]), sceneId: idSchema.optional(), payload: payloadSchema.optional(), confirm: confirmSchema }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_flow",
+        description: "保存或删除无代码流程配置；必须 confirm=true，否则只返回预览。",
+        schema: z.object({ action: z.enum(["save", "delete"]), ...payloadWriteShape }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_stage",
+        description: "保存、启停或删除阶段配置；必须 confirm=true，否则只返回预览。",
+        schema: z.object({ action: z.enum(["save", "status", "delete"]), ...payloadWriteShape }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_custom_button",
+        description: "保存、删除、执行自定义按钮或保存按钮填写字段；必须 confirm=true，否则只返回预览。",
+        schema: z.object({ action: z.enum(["save", "delete", "execute", "saveFieldData"]), ...payloadWriteShape }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_role",
+        description: "保存/删除/复制无代码角色，或保存角色模块、用户、字段权限关系；必须 confirm=true，否则只返回预览。",
+        schema: z.object({
+            action: z.enum(["save", "delete", "copy", "saveModules", "saveUsers", "saveFields", "saveUserRole", "deleteUserRole"]),
+            roleId: idSchema.optional(),
+            payload: payloadSchema.optional(),
+            confirm: confirmSchema
+        }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_tab",
+        description: "保存、启停或删除无代码详情页 Tab；必须 confirm=true，否则只返回预览。",
+        schema: z.object({ action: z.enum(["save", "status", "delete"]), id: idSchema.optional(), payload: payloadSchema.optional(), confirm: confirmSchema }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_workflow",
+        description: "填写/转交流程、审批、自选节点、标记处理记录已查看，或保存阶段数据和评论；必须 confirm=true。",
+        schema: z.object({
+            operation: z.enum(["fillValue", "transfer", "audit", "optional", "viewDealRecord", "stageData", "stageCommentSave", "stageCommentRemove"]),
+            ...extendedContextShape,
+            confirm: confirmSchema
+        }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_followup",
+        description: "保存跟进字段/配置状态/数据/评论，或删除跟进配置、记录、评论；必须 confirm=true。",
+        schema: z.object({
+            operation: z.enum(["fieldSave", "updateStatus", "deleteConfig", "dataSave", "deleteData", "commentSave", "deleteComment"]),
+            ...extendedContextShape,
+            confirm: confirmSchema
+        }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_configuration",
+        description: "保存/删除自定义分类、提醒、校验规则，或保存用户搜索、外部字段映射、模块文件、应用分类、Tab 绑定和多语言；必须 confirm=true。",
+        schema: z.object({
+            operation: z.enum(["customCategorySave", "customCategoryDelete", "customNoticeSave", "customNoticeDelete", "dataCheckSave", "dataCheckDelete", "dataCheckSort", "userSearchSave", "externalFieldMappingSave", "moduleFileSave", "categorySave", "categoryDelete", "tabBind", "languageSave"]),
+            ...extendedContextShape,
+            confirm: confirmSchema
+        }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_printing",
+        description: "新增/修改/复制/删除打印模板、生成打印/预览内容或保存打印记录；必须 confirm=true；不代理 PDF/Word 下载流。",
+        schema: z.object({
+            operation: z.enum(["add", "update", "copy", "delete", "print", "preview", "recordSave"]),
+            templateId: idSchema.optional(),
+            ...extendedContextShape,
+            confirm: confirmSchema
+        }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_message",
+        description: "将无代码消息设为已读或删除；必须 confirm=true。",
+        schema: z.object({ operation: z.enum(["setRead", "delete"]), ...payloadWriteShape }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_integration",
+        description: "开放或关闭指定无代码模块；必须 confirm=true。",
+        schema: z.object({ operation: z.enum(["openModules", "closeModules"]), ...payloadWriteShape }),
+        access: "write",
+        destructive: true
+    },
+    {
+        name: "nocode_write_marketplace",
+        description: "发布/复制/清空应用模板，或维护应用分类、收藏、移动与排序；必须 confirm=true。clearApps 会清空应用，风险极高。",
+        schema: z.object({
+            operation: z.enum(["publish", "publishAll", "copy", "clearApps", "categorySave", "store", "move", "customCategorySave", "sort"]),
+            companyId: idSchema.optional(),
+            ...extendedContextShape,
+            confirm: confirmSchema
+        }),
+        access: "write",
+        destructive: true
+    }
+];
+export function createNocodeToolHandlers(config = {}) {
+    const client = new CrmClient(config);
+    return {
+        nocode_list_applications: async () => readonlyResult("/moduleMetadata/customAppList", await client.post("/moduleMetadata/customAppList")),
+        nocode_get_application: async (args) => {
+            const applicationId = requiredId(args.applicationId, "applicationId");
+            const targetPath = `/moduleMetadata/queryById/${applicationId}`;
+            return readonlyResult(targetPath, await client.post(targetPath));
+        },
+        nocode_list_modules: async (args) => {
+            const applicationId = requiredId(args.applicationId, "applicationId");
+            const mode = args.mode ?? "released";
+            const targetPath = mode === "latest"
+                ? `/moduleM/latest/list/${applicationId}`
+                : mode === "bi"
+                    ? `/moduleM/bi/list/${applicationId}`
+                    : mode === "all"
+                        ? `/moduleM/list/${applicationId}`
+                        : `/moduleM/released/list/${applicationId}`;
+            return readonlyResult(targetPath, await client.post(targetPath), { mode });
+        },
+        nocode_get_module: async (args) => {
+            const moduleId = requiredId(args.moduleId, "moduleId");
+            if (args.version !== undefined) {
+                const version = requiredVersion(args.version);
+                const targetPath = `/moduleM/queryDetail/${moduleId}/${version}`;
+                return readonlyResult(targetPath, await client.post(targetPath));
+            }
+            const targetPath = `/moduleM/queryById/${moduleId}`;
+            return readonlyResult(targetPath, await client.post(targetPath, undefined, { isLatest: args.isLatest ?? true }));
+        },
+        nocode_get_module_schema: async (args) => {
+            const moduleId = requiredId(args.moduleId, "moduleId");
+            const version = requiredVersion(args.version);
+            const query = cleanObject({ moduleId: numericValue(moduleId), version, categoryId: args.categoryId });
+            const [fields, form, listHead, layout, unionModules] = await Promise.all([
+                client.post("/moduleField/queryList", query),
+                client.post("/moduleField/formList", query),
+                client.post("/moduleField/queryListHead", query),
+                client.post(`/moduleM/pageLayout/${moduleId}/${version}`),
+                client.post(`/moduleM/unionModules/${moduleId}/${version}`)
+            ]);
+            const extended = args.includeExtended === false
+                ? undefined
+                : {
+                    options: await client.post(`/moduleFieldOptions/list/${moduleId}/${version}`),
+                    formulas: await client.post(`/moduleFieldFormula/list/${moduleId}/${version}`),
+                    tags: await client.post(`/moduleFieldTags/list/${moduleId}/${version}`),
+                    serialNumberRules: await client.post(`/moduleFieldSerialNumberRules/list/${moduleId}/${version}`)
+                };
+            return {
+                readonly: true,
+                moduleId,
+                version,
+                fields,
+                form,
+                listHead,
+                layout,
+                unionModules,
+                ...extended
+            };
+        },
+        nocode_search_records: async (args) => {
+            const moduleId = requiredId(args.moduleId, "moduleId");
+            const targetPath = `/moduleData/queryPageList/${moduleId}`;
+            // 分页上限由工具 schema 控制，不能让透传 payload 绕过顶层的 page/limit 约束。
+            const body = cleanObject({ ...safePayload(args.payload), page: args.page ?? 1, limit: args.limit ?? 15 });
+            return readonlyResult(targetPath, await client.post(targetPath, body), { body });
+        },
+        nocode_get_record: async (args) => {
+            const dataId = requiredId(args.dataId, "dataId");
+            const targetPath = `/moduleFieldData/query/${dataId}/${args.replaceMask ?? true}`;
+            return readonlyResult(targetPath, await client.post(targetPath));
+        },
+        nocode_calculate_formula: async (args) => readonlyResult("/moduleFieldData/calculateFormula", await client.post("/moduleFieldData/calculateFormula", safePayload(args.payload))),
+        nocode_check_duplicate: async (args) => readonlyResult("/moduleFieldData/doubleCheck", await client.post("/moduleFieldData/doubleCheck", safePayload(args.payload))),
+        nocode_list_team_members: async (args) => {
+            const moduleId = requiredId(args.moduleId, "moduleId");
+            const dataId = requiredId(args.dataId, "dataId");
+            const [members, currentUser] = await Promise.all([
+                client.post(`/moduleFieldData/teamMember/${moduleId}/${dataId}`),
+                client.post(`/moduleFieldData/teamMemberInfo/${moduleId}/${dataId}`)
+            ]);
+            return { readonly: true, moduleId, dataId, members, currentUser };
+        },
+        nocode_get_permissions: async (args) => queryPermissions(client, args),
+        nocode_list_scenes: async (args) => {
+            const moduleId = requiredId(args.moduleId, "moduleId");
+            const targetPath = `/moduleScene/list/${moduleId}`;
+            return readonlyResult(targetPath, await client.post(targetPath));
+        },
+        nocode_list_flows: async (args) => readonlyResult("/moduleFlow/queryFlow", await client.post("/moduleFlow/queryFlow", undefined, safePayload(args.payload))),
+        nocode_list_stages: async (args) => {
+            let targetPath;
+            if (args.dataId !== undefined) {
+                targetPath = `/moduleStageSetting/queryList/${requiredId(args.dataId, "dataId")}`;
+            }
+            else {
+                targetPath = `/moduleStageSetting/queryList/${requiredId(args.moduleId, "moduleId")}/${requiredVersion(args.version)}`;
+            }
+            return readonlyResult(targetPath, await client.post(targetPath));
+        },
+        nocode_list_custom_buttons: async (args) => {
+            const targetPath = `/moduleCustomButton/queryList/${requiredId(args.moduleId, "moduleId")}/${requiredVersion(args.version)}`;
+            return readonlyResult(targetPath, await client.post(targetPath));
+        },
+        nocode_list_tabs: async (args) => {
+            const targetPath = `/moduleTab/queryList/${requiredId(args.moduleId, "moduleId")}`;
+            return readonlyResult(targetPath, await client.post(targetPath));
+        },
+        nocode_get_module_file: async (args) => readonlyResult("/moduleFile/query", await client.post("/moduleFile/query", safePayload(args.payload))),
+        nocode_query_fields: async (args) => executeNocodeRead(client, queryFieldRoute(args)),
+        nocode_query_records: async (args) => executeNocodeRead(client, queryRecordRoute(args)),
+        nocode_query_workflow: async (args) => executeNocodeRead(client, queryWorkflowRoute(args)),
+        nocode_query_followups: async (args) => executeNocodeRead(client, queryFollowUpRoute(args)),
+        nocode_query_configuration: async (args) => executeNocodeRead(client, queryConfigurationRoute(args)),
+        nocode_query_printing: async (args) => executeNocodeRead(client, queryPrintingRoute(args)),
+        nocode_query_messages: async (args) => executeNocodeRead(client, queryMessageRoute(args)),
+        nocode_query_integrations: async (args) => executeNocodeRead(client, queryIntegrationRoute(args)),
+        nocode_query_marketplace: async (args) => executeNocodeRead(client, queryMarketplaceRoute(args)),
+        nocode_write_application: async (args) => executeApplicationWrite(client, args),
+        nocode_write_module: async (args) => executeModuleWrite(client, args),
+        nocode_write_field: async (args) => executePayloadWrite(client, args, {
+            save: "/moduleField/save",
+            sort: "/moduleField/setFieldSort",
+            style: "/moduleField/setFieldStyle",
+            fixedSort: "/moduleField/fixed/setFieldSort",
+            fixedStyle: "/moduleField/fixed/setFieldStyle"
+        }),
+        nocode_write_record: async (args) => executePayloadWrite(client, args, {
+            save: "/moduleFieldData/save",
+            delete: "/moduleFieldData/delete",
+            transfer: "/moduleFieldData/transfer",
+            setCategory: "/moduleFieldData/setDataCategory"
+        }),
+        nocode_write_team: async (args) => executePayloadWrite(client, args, {
+            save: "/moduleFieldData/saveTeamMember",
+            remove: "/moduleFieldData/removeTeamMember"
+        }),
+        nocode_write_scene: async (args) => executeSceneWrite(client, args),
+        nocode_write_flow: async (args) => executePayloadWrite(client, args, {
+            save: "/moduleFlow/saveFlow",
+            delete: "/moduleFlow/delete"
+        }),
+        nocode_write_stage: async (args) => executePayloadWrite(client, args, {
+            save: "/moduleStageSetting/save",
+            status: "/moduleStageSetting/updateStatus",
+            delete: "/moduleStageSetting/delete"
+        }),
+        nocode_write_custom_button: async (args) => executePayloadWrite(client, args, {
+            save: "/moduleCustomButton/save",
+            delete: "/moduleCustomButton/delete",
+            execute: "/moduleCustomButton/execute",
+            saveFieldData: "/moduleCustomButton/saveFieldData"
+        }),
+        nocode_write_role: async (args) => executeRoleWrite(client, args),
+        nocode_write_tab: async (args) => executeTabWrite(client, args),
+        nocode_write_workflow: async (args) => executeNocodeWrite(client, args, writeWorkflowRoute(args)),
+        nocode_write_followup: async (args) => executeNocodeWrite(client, args, writeFollowUpRoute(args)),
+        nocode_write_configuration: async (args) => executeNocodeWrite(client, args, writeConfigurationRoute(args)),
+        nocode_write_printing: async (args) => executeNocodeWrite(client, args, writePrintingRoute(args)),
+        nocode_write_message: async (args) => executeNocodeWrite(client, args, writeMessageRoute(args)),
+        nocode_write_integration: async (args) => executeNocodeWrite(client, args, writeIntegrationRoute(args)),
+        nocode_write_marketplace: async (args) => executeNocodeWrite(client, args, writeMarketplaceRoute(args))
+    };
+}
+async function executeNocodeRead(client, route) {
+    return readonlyResult(route.targetPath, await client.post(route.targetPath, route.body, route.query), cleanObject({ operation: route.operation, body: route.body, query: route.query }));
+}
+function executeNocodeWrite(client, args, route) {
+    return confirmedPost(client, args, route.operation, route.targetPath, route.body, route.query);
+}
+function queryFieldRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    switch (operation) {
+        case "exportHead": return bodyRoute(operation, "/moduleField/queryExportHeadList", payload);
+        case "fixedListHead": return bodyRoute(operation, "/moduleField/fixed/queryListHead", payload);
+        case "verify": return bodyRoute(operation, "/moduleField/verify", payload);
+        case "checkDelete": return bodyRoute(operation, "/moduleField/checkFieldDelete", payload);
+        case "union": return pathRoute(operation, `/moduleField/queryUnionList/${requiredId(args.targetModuleId, "targetModuleId")}/${requiredId(args.moduleId, "moduleId")}`);
+        case "dashboardHead": return bodyRoute(operation, "/moduleField/queryListHeadForDashboard", payload);
+        case "dashboardModule": return bodyRoute(operation, "/moduleM/queryByIdForDashboard", payload);
+        case "defaultList": return moduleVersionRoute(operation, "/moduleFieldDefault/list", args);
+        case "defaultValues": return moduleVersionRoute(operation, "/moduleFieldDefault/values", args);
+        case "defaultFiltered": return bodyRoute(operation, "/moduleFieldDefault/values", payload);
+        case "defaultFormula": return bodyRoute(operation, "/moduleFieldDefault/values/formula", payload);
+        case "treeConfig": return moduleVersionRoute(operation, "/moduleFieldTree/list", args);
+        case "treeData": return bodyRoute(operation, "/moduleTreeData/queryTreeData", payload);
+        case "statisticConfig": return moduleVersionRoute(operation, "/moduleFieldStatistic/query", args);
+        case "statisticValues": return bodyRoute(operation, "/moduleFieldStatistic/values", payload);
+        case "statisticUnion": return moduleVersionRoute(operation, "/moduleStatisticFieldUnion/query", args);
+        default: return unsupportedRoute("字段查询", operation);
+    }
+}
+function queryRecordRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    switch (operation) {
+        case "byDataIds": return bodyRoute(operation, "/moduleData/queryByDataIds", payload);
+        case "raw": return pathRoute(operation, `/moduleFieldData/query/${requiredId(args.dataId, "dataId")}`);
+        case "mainField": return pathRoute(operation, `/moduleFieldData/mainField/${requiredId(args.dataId, "dataId")}`);
+        case "mainFields": return bodyRoute(operation, "/moduleFieldData/mainField/queryByDataIds", payload);
+        case "mainFieldData": return bodyRoute(operation, "/moduleFieldData/queryMainFieldData", requiredIds(args.ids, "ids"));
+        case "fieldStatistic": return bodyRoute(operation, "/moduleFieldData/fieldStatistic", payload);
+        case "operationRecords": return pathRoute(operation, `/moduleOperationRecord/query/${requiredId(args.moduleId, "moduleId")}/${requiredId(args.dataId, "dataId")}`);
+        case "customButtonDealRecords": return pathRoute(operation, `/moduleCustomButton/dealRecord/${requiredId(args.moduleId, "moduleId")}/${requiredId(args.dataId, "dataId")}`);
+        case "tabBoundDataIds": return pathRoute(operation, `/moduleTabDataBind/getBoundDataIds/${requiredId(args.dataId, "dataId")}/${requiredId(args.tabId, "tabId")}`);
+        default: return unsupportedRoute("记录查询", operation);
+    }
+}
+function queryWorkflowRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    switch (operation) {
+        case "preview": return bodyRoute(operation, "/moduleFlow/preview", payload);
+        case "flowDetail": return bodyRoute(operation, "/moduleFlow/flowDetail", payload);
+        case "dealDetail": return queryRoute(operation, "/moduleFlow/dealDetail", payload);
+        case "examineRecord": return pathRoute(operation, `/moduleFlowExamine/record/${requiredId(args.moduleId, "moduleId")}/${requiredId(args.dataId, "dataId")}/${requiredId(args.typeId, "typeId")}`);
+        case "dealRecords": return bodyRoute(operation, "/moduleFlowDealRecord/queryList", payload);
+        case "stageFields": return stageFieldRoute(operation, "/moduleStageSetting/field/list", args);
+        case "stageForm": return stageFieldRoute(operation, "/moduleStageSetting/field/formList", args);
+        case "stageData": return bodyRoute(operation, "/moduleStageData/queryList", payload);
+        case "stageComments": return pathRoute(operation, `/moduleStageData/comment/list/${requiredId(args.dataId, "dataId")}`);
+        default: return unsupportedRoute("流程查询", operation);
+    }
+}
+function writeWorkflowRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    switch (operation) {
+        case "fillValue": return bodyRoute(operation, "/moduleFlow/fill/saveFieldValue", payload);
+        case "transfer": return queryRoute(operation, "/moduleFlow/transferFlow", payload);
+        case "audit": return bodyRoute(operation, "/moduleFlowExamine/auditExamine", payload);
+        case "optional": return bodyRoute(operation, "/moduleFlowOptional/save", payload);
+        case "viewDealRecord": return pathRoute(operation, `/moduleFlowDealRecord/view/${requiredId(args.id, "id")}`);
+        case "stageData": return bodyRoute(operation, "/moduleStageData/save", payload);
+        case "stageCommentSave": return bodyRoute(operation, "/moduleStageData/comment/save", payload);
+        case "stageCommentRemove": return bodyRoute(operation, "/moduleStageData/comment/remove", payload);
+        default: return unsupportedRoute("流程写操作", operation);
+    }
+}
+function queryFollowUpRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    const moduleId = () => requiredId(args.moduleId, "moduleId");
+    const version = () => requiredVersion(args.version);
+    const followUpId = () => requiredId(args.followUpId, "followUpId");
+    switch (operation) {
+        case "fieldList": return pathRoute(operation, `/moduleFollowUp/field/list/${moduleId()}/${version()}/${followUpId()}`);
+        case "fieldForm": return pathRoute(operation, `/moduleFollowUp/field/formList/${moduleId()}/${version()}/${followUpId()}`);
+        case "availableForm": return pathRoute(operation, `/moduleFollowUp/field/availableFormList/${moduleId()}/${version()}`);
+        case "configList": return pathRoute(operation, `/moduleFollowUp/list/${moduleId()}/${version()}`);
+        case "dataPage": return bodyRoute(operation, "/moduleFollowUpData/pageList", payload);
+        case "recordPage": return bodyRoute(operation, "/moduleFollowUpRecord/pageList", payload);
+        case "comments": return pathRoute(operation, `/moduleFollowUpRecordComment/list/${requiredId(args.recordId, "recordId")}`);
+        default: return unsupportedRoute("跟进查询", operation);
+    }
+}
+function writeFollowUpRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    switch (operation) {
+        case "fieldSave": return bodyRoute(operation, "/moduleFollowUp/field/save", payload);
+        case "updateStatus": return bodyRoute(operation, "/moduleFollowUp/updateStatus", payload);
+        case "deleteConfig": return pathRoute(operation, `/moduleFollowUp/delete/${requiredId(args.moduleId, "moduleId")}/${requiredVersion(args.version)}/${requiredId(args.followUpId, "followUpId")}`);
+        case "dataSave": return bodyRoute(operation, "/moduleFollowUpData/save", payload);
+        case "deleteData": return pathRoute(operation, `/moduleFollowUpData/delete/${requiredId(args.recordId, "recordId")}`);
+        case "commentSave": return bodyRoute(operation, "/moduleFollowUpRecordComment/save", payload);
+        case "deleteComment": return pathRoute(operation, `/moduleFollowUpRecordComment/delete/${requiredId(args.commentId, "commentId")}`);
+        default: return unsupportedRoute("跟进写操作", operation);
+    }
+}
+function queryConfigurationRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    switch (operation) {
+        case "scene": return pathRoute(operation, `/moduleScene/${requiredId(args.id, "id")}`);
+        case "customCategoryConfig": return moduleVersionRoute(operation, "/moduleCustomCategory/queryList", args);
+        case "customCategories": return pathRoute(operation, "/moduleCustomCategory/list");
+        case "customNotice": return moduleVersionRoute(operation, "/moduleCustomNotice/queryList", args);
+        case "dataCheckRules": return moduleVersionRoute(operation, "/moduleDataCheckRule/queryList", args);
+        case "dataCheck": return bodyRoute(operation, "/moduleDataCheckRule/dataCheck", payload);
+        case "userSearch": return pathRoute(operation, `/moduleUserSearch/config/${requiredId(args.moduleId, "moduleId")}`);
+        case "externalFieldMappings": return moduleVersionRoute(operation, "/moduleExternalFieldMapping/queryList", args);
+        case "languageModule": return pathRoute(operation, `/moduleLanguage/list/${requiredId(args.moduleId, "moduleId")}/${requiredVersion(args.version)}/${requiredSegment(args.language, "language")}`);
+        case "languageApplication": return pathRoute(operation, `/moduleLanguage/listByApplicationId/${requiredId(args.applicationId, "applicationId")}/${requiredSegment(args.language, "language")}`);
+        case "languageCurrent": return pathRoute(operation, `/moduleLanguage/listByLanguage/${requiredSegment(args.language, "language")}`);
+        default: return unsupportedRoute("配置查询", operation);
+    }
+}
+function writeConfigurationRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    switch (operation) {
+        case "customCategorySave": return bodyRoute(operation, "/moduleCustomCategory/save", payload);
+        case "customCategoryDelete": return pathRoute(operation, `/moduleCustomCategory/delete/${requiredId(args.categoryId, "categoryId")}/${requiredVersion(args.version)}`);
+        case "customNoticeSave": return bodyRoute(operation, "/moduleCustomNotice/save", payload);
+        case "customNoticeDelete": return pathRoute(operation, `/moduleCustomNotice/delete/${requiredId(args.noticeId, "noticeId")}/${requiredVersion(args.version)}`);
+        case "dataCheckSave": return bodyRoute(operation, "/moduleDataCheckRule/save", payload);
+        case "dataCheckDelete": return pathRoute(operation, `/moduleDataCheckRule/delete/${requiredId(args.ruleId, "ruleId")}/${requiredVersion(args.version)}`);
+        case "dataCheckSort": return bodyRoute(operation, `/moduleDataCheckRule/sort/${requiredId(args.moduleId, "moduleId")}/${requiredVersion(args.version)}`, requiredIds(args.ids, "ids"));
+        case "userSearchSave": return bodyRoute(operation, "/moduleUserSearch/save", payload);
+        case "externalFieldMappingSave": return bodyRoute(operation, "/moduleExternalFieldMapping/save", payload);
+        case "moduleFileSave": return bodyRoute(operation, "/moduleFile/save", payload);
+        case "categorySave": return bodyRoute(operation, "/moduleCategory/save", payload);
+        case "categoryDelete": return pathRoute(operation, `/moduleCategory/delete/${requiredId(args.categoryId, "categoryId")}`);
+        case "tabBind": return bodyRoute(operation, "/moduleTabDataBind/bindData", payload);
+        case "languageSave": return bodyRoute(operation, "/moduleLanguage/save", payload);
+        default: return unsupportedRoute("配置写操作", operation);
+    }
+}
+function queryPrintingRoute(args) {
+    const operation = String(args.operation);
+    switch (operation) {
+        case "fields": return moduleVersionRoute(operation, "/modulePrintTemplate/getFields", args);
+        case "templates": return bodyRoute(operation, `/modulePrintTemplate/list/${requiredId(args.moduleId, "moduleId")}/${requiredVersion(args.version)}`, safePayload(args.payload));
+        case "template": return bodyRoute(operation, "/modulePrintTemplate/getOne", safePayload(args.payload));
+        case "records": return pathRoute(operation, `/modulePrintTemplate/printRecord/list/${requiredId(args.moduleId, "moduleId")}`);
+        case "record": return pathRoute(operation, `/modulePrintTemplate/printRecord/${requiredId(args.recordId, "recordId")}`);
+        default: return unsupportedRoute("打印查询", operation);
+    }
+}
+function writePrintingRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    switch (operation) {
+        case "add": return bodyRoute(operation, "/modulePrintTemplate/add", payload);
+        case "update": return bodyRoute(operation, "/modulePrintTemplate/update", payload);
+        case "copy": return bodyRoute(operation, "/modulePrintTemplate/copy", payload);
+        case "delete": return bodyRoute(operation, "/modulePrintTemplate/delete", payload);
+        case "print": return queryRoute(operation, "/modulePrintTemplate/print", {
+            templateId: numericValue(requiredId(args.templateId, "templateId")),
+            dataId: numericValue(requiredId(args.dataId, "dataId"))
+        });
+        case "preview": return bodyRoute(operation, "/modulePrintTemplate/preview", payload);
+        case "recordSave": return bodyRoute(operation, "/modulePrintTemplate/printRecord/save", payload);
+        default: return unsupportedRoute("打印写操作", operation);
+    }
+}
+function queryMessageRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    switch (operation) {
+        case "summary": return pathRoute(operation, "/moduleMessage/list");
+        case "page": return bodyRoute(operation, "/moduleMessage/listMessage", payload);
+        case "moduleType": return pathRoute(operation, `/moduleMessage/queryList/${requiredId(args.moduleId, "moduleId")}/${requiredInteger(args.type, "type")}`);
+        case "importProgress": return queryRoute(operation, "/moduleMessage/queryImportNum", { messageId: numericValue(requiredId(args.messageId, "messageId")) });
+        case "importInfo": return queryRoute(operation, "/moduleMessage/queryImportInfo", { messageId: numericValue(requiredId(args.messageId, "messageId")) });
+        default: return unsupportedRoute("消息查询", operation);
+    }
+}
+function writeMessageRoute(args) {
+    const operation = String(args.operation);
+    const paths = { setRead: "/moduleMessage/setRead", delete: "/moduleMessage/delete" };
+    const targetPath = paths[operation];
+    if (!targetPath)
+        return unsupportedRoute("消息写操作", operation);
+    return bodyRoute(operation, targetPath, safePayload(args.payload));
+}
+function queryIntegrationRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    switch (operation) {
+        case "externalApplications": return bodyRoute(operation, "/moduleExternalApplication/list", payload);
+        case "externalModules": return pathRoute(operation, `/moduleExternal/list/${requiredId(args.applicationId, "applicationId")}`);
+        case "externalModule": return pathRoute(operation, `/moduleExternal/queryByModuleId/${requiredId(args.moduleId, "moduleId")}`);
+        case "moduleByExternalId": return pathRoute(operation, `/moduleExternal/queryModuleById/${requiredId(args.externalModuleId, "externalModuleId")}`);
+        case "openModules": return bodyRoute(operation, "/moduleOpen/pageList", payload);
+        case "openApplication": return pathRoute(operation, `/moduleOpenMetadata/queryById/${requiredId(args.applicationId, "applicationId")}`);
+        case "openConfig": return pathRoute(operation, `/moduleOpenConfig/queryList/${requiredId(args.moduleId, "moduleId")}/${requiredInteger(args.configType, "configType")}`);
+        case "openRecords": return bodyRoute(operation, `/moduleOpenData/pageList/${requiredId(args.moduleId, "moduleId")}`, payload);
+        case "openRecord": return pathRoute(operation, `/moduleOpenData/query/${requiredId(args.dataId, "dataId")}/${args.replaceMask ?? true}`);
+        case "openBoundDataIds": return pathRoute(operation, `/moduleOpenData/getBoundDataIds/${requiredId(args.dataId, "dataId")}/${requiredId(args.tabId, "tabId")}`);
+        default: return unsupportedRoute("开放能力查询", operation);
+    }
+}
+function writeIntegrationRoute(args) {
+    const operation = String(args.operation);
+    const paths = {
+        openModules: "/moduleOpen/openModule",
+        closeModules: "/moduleOpen/closeModule"
+    };
+    const targetPath = paths[operation];
+    if (!targetPath)
+        return unsupportedRoute("开放能力写操作", operation);
+    return bodyRoute(operation, targetPath, requiredIds(args.ids, "ids"));
+}
+function queryMarketplaceRoute(args) {
+    const operation = String(args.operation);
+    const paths = {
+        manageCompany: "/moduleAppTemplate/getManageCompany",
+        systemCategories: "/moduleAppTemplate/appCategory/list",
+        systemApps: "/moduleAppTemplate/app/list",
+        publishStatus: "/moduleAppTemplate/queryAppPublishStatus",
+        appCategories: "/moduleAppCategory/app/list"
+    };
+    const targetPath = paths[operation];
+    if (!targetPath)
+        return unsupportedRoute("应用市场查询", operation);
+    return pathRoute(operation, targetPath);
+}
+function writeMarketplaceRoute(args) {
+    const operation = String(args.operation);
+    const payload = safePayload(args.payload);
+    switch (operation) {
+        case "publish": return pathRoute(operation, `/moduleAppTemplate/publish/${requiredId(args.applicationId, "applicationId")}`);
+        case "publishAll": return pathRoute(operation, "/moduleAppTemplate/publishAll");
+        case "copy": return pathRoute(operation, `/moduleAppTemplate/copy/${requiredId(args.companyId, "companyId")}`);
+        case "clearApps": return pathRoute(operation, "/moduleAppTemplate/clear");
+        case "categorySave": return bodyRoute(operation, "/moduleAppCategory/save", payload);
+        case "store": return bodyRoute(operation, "/moduleAppCategory/app/store", payload);
+        case "move": return bodyRoute(operation, "/moduleAppCategory/move", payload);
+        case "customCategorySave": return bodyRoute(operation, "/moduleAppCategory/saveAppCustomCategory", payload);
+        case "sort": return bodyRoute(operation, "/moduleAppCategory/sort", payload);
+        default: return unsupportedRoute("应用市场写操作", operation);
+    }
+}
+function bodyRoute(operation, targetPath, body) {
+    return { operation, targetPath, body };
+}
+function queryRoute(operation, targetPath, query) {
+    return { operation, targetPath, query };
+}
+function pathRoute(operation, targetPath) {
+    return { operation, targetPath };
+}
+function moduleVersionRoute(operation, basePath, args) {
+    return pathRoute(operation, `${basePath}/${requiredId(args.moduleId, "moduleId")}/${requiredVersion(args.version)}`);
+}
+function stageFieldRoute(operation, basePath, args) {
+    return pathRoute(operation, `${basePath}/${requiredId(args.moduleId, "moduleId")}/${requiredVersion(args.version)}/${requiredId(args.stageId, "stageId")}`);
+}
+function unsupportedRoute(domain, operation) {
+    throw new Error(`不支持的无代码${domain}：${operation}`);
+}
+async function queryPermissions(client, args) {
+    switch (args.kind) {
+        case "auth":
+            return readonlyResult("/moduleRole/auth", await client.post("/moduleRole/auth"));
+        case "roles": {
+            const applicationId = requiredId(args.applicationId, "applicationId");
+            const targetPath = `/moduleRole/list/${applicationId}`;
+            return readonlyResult(targetPath, await client.post(targetPath));
+        }
+        case "rolesByIds":
+            return readonlyResult("/moduleRole/listByRoleId", await client.post("/moduleRole/listByRoleId", requiredIds(args.ids, "ids")));
+        case "usersRoles":
+            return readonlyResult("/moduleRole/roles/users", await client.post("/moduleRole/roles/users", requiredIds(args.ids, "ids")));
+        case "viewableUserIds": {
+            const moduleId = requiredId(args.moduleId, "moduleId");
+            const targetPath = `/moduleRole/queryViewableUserIds/${moduleId}`;
+            return readonlyResult(targetPath, await client.post(targetPath));
+        }
+        case "data": {
+            const dataId = requiredId(args.dataId, "dataId");
+            const targetPath = `/moduleRole/dataAuth/${dataId}`;
+            return readonlyResult(targetPath, await client.post(targetPath));
+        }
+        case "field": {
+            const moduleId = requiredId(args.moduleId, "moduleId");
+            const userId = requiredId(args.userId, "userId");
+            const targetPath = `/moduleRole/fieldAuth/${moduleId}/${userId}`;
+            return readonlyResult(targetPath, await client.post(targetPath));
+        }
+        case "roleField":
+            return readonlyResult("/moduleRole/roleField", await client.post("/moduleRole/roleField", safePayload(args.payload)));
+        default:
+            throw new Error(`不支持的无代码权限查询类型：${String(args.kind)}`);
+    }
+}
+async function executeApplicationWrite(client, args) {
+    const action = String(args.action);
+    let targetPath;
+    let body;
+    let query;
+    switch (action) {
+        case "create":
+            targetPath = "/moduleMetadata/save";
+            body = safePayload(args.payload);
+            break;
+        case "update":
+            targetPath = "/moduleMetadata/update";
+            body = safePayload(args.payload);
+            break;
+        case "status":
+            targetPath = `/moduleMetadata/updateStatus/${requiredId(args.applicationId, "applicationId")}`;
+            query = { status: requiredInteger(args.status, "status") };
+            break;
+        case "delete":
+            targetPath = `/moduleMetadata/delete/${requiredId(args.applicationId, "applicationId")}`;
+            break;
+        case "sort":
+            targetPath = "/moduleMetadata/setAppSettingSort";
+            body = requiredIds(args.ids, "ids");
+            break;
+        case "install":
+            targetPath = `/moduleMetadata/install/${requiredId(args.applicationId, "applicationId")}`;
+            break;
+        default:
+            throw new Error(`不支持的无代码应用写操作：${action}`);
+    }
+    return confirmedPost(client, args, action, targetPath, body, query);
+}
+async function executeModuleWrite(client, args) {
+    const action = String(args.action);
+    let targetPath;
+    let body;
+    let query;
+    switch (action) {
+        case "save":
+            targetPath = "/moduleM/save";
+            body = safePayload(args.payload);
+            break;
+        case "status":
+            targetPath = `/moduleM/updateStatus/${requiredId(args.moduleId, "moduleId")}`;
+            query = { isEnable: requiredBoolean(args.isEnable, "isEnable") };
+            break;
+        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;
+        case "delete":
+            targetPath = `/moduleM/delete/${requiredId(args.moduleId, "moduleId")}`;
+            break;
+        case "layout":
+            targetPath = "/moduleM/pageLayout";
+            body = safePayload(args.payload);
+            break;
+        case "deleteCancelledCompanyData":
+            targetPath = "/moduleM/deleteCancelCompanyData";
+            body = safePayload(args.payload);
+            break;
+        case "dashboardSave":
+            targetPath = "/moduleM/addOrUpdateModuleForDashboard";
+            body = safePayload(args.payload);
+            break;
+        case "dashboardRemove":
+            targetPath = "/moduleM/removeModuleForDashboard";
+            body = safePayload(args.payload);
+            break;
+        default:
+            throw new Error(`不支持的无代码模块写操作：${action}`);
+    }
+    return confirmedPost(client, args, action, targetPath, body, query);
+}
+async function executePayloadWrite(client, args, paths) {
+    const action = String(args.action);
+    const targetPath = paths[action];
+    if (!targetPath) {
+        throw new Error(`不支持的无代码写操作：${action}`);
+    }
+    return confirmedPost(client, args, action, targetPath, safePayload(args.payload));
+}
+async function executeSceneWrite(client, args) {
+    const action = String(args.action);
+    const targetPath = action === "delete" || action === "default"
+        ? `/moduleScene/${action}/${requiredId(args.sceneId, "sceneId")}`
+        : action === "add" || action === "update" || action === "config"
+            ? `/moduleScene/${action}`
+            : "";
+    if (!targetPath) {
+        throw new Error(`不支持的无代码场景写操作：${action}`);
+    }
+    const body = action === "delete" || action === "default" ? undefined : safePayload(args.payload);
+    return confirmedPost(client, args, action, targetPath, body);
+}
+async function executeRoleWrite(client, args) {
+    const action = String(args.action);
+    const pathMap = {
+        save: "/moduleRole/save",
+        saveModules: "/moduleRole/module/save",
+        saveUsers: "/moduleRole/user/save",
+        saveFields: "/moduleRole/roleField/save",
+        saveUserRole: "/moduleRole/userRole/save",
+        deleteUserRole: "/moduleRole/userRole/delete"
+    };
+    const targetPath = action === "delete" || action === "copy"
+        ? `/moduleRole/${action}/${requiredId(args.roleId, "roleId")}`
+        : pathMap[action];
+    if (!targetPath) {
+        throw new Error(`不支持的无代码角色写操作：${action}`);
+    }
+    const body = action === "delete" || action === "copy" ? undefined : safePayload(args.payload);
+    return confirmedPost(client, args, action, targetPath, body);
+}
+async function executeTabWrite(client, args) {
+    const action = String(args.action);
+    const targetPath = action === "delete"
+        ? `/moduleTab/delete/${requiredId(args.id, "id")}`
+        : action === "save"
+            ? "/moduleTab/save"
+            : action === "status"
+                ? "/moduleTab/updateStatus"
+                : "";
+    if (!targetPath) {
+        throw new Error(`不支持的无代码 Tab 写操作：${action}`);
+    }
+    const body = action === "delete" ? undefined : safePayload(args.payload);
+    return confirmedPost(client, args, action, targetPath, body);
+}
+async function confirmedPost(client, args, action, targetPath, body, query) {
+    // 保持旧 MCP 的既有写操作语义：未明确确认时只回显将要调用的固定接口。
+    if (args.confirm !== true) {
+        return {
+            preview: true,
+            message: "写入前预览：未传 confirm=true，MCP 不会调用 72CRM 无代码写接口。",
+            action,
+            targetPath,
+            body,
+            query
+        };
+    }
+    return {
+        preview: false,
+        action,
+        targetPath,
+        body,
+        query,
+        data: await client.post(targetPath, body, query)
+    };
+}
+function readonlyResult(targetPath, data, extra = {}) {
+    return { readonly: true, targetPath, ...extra, data };
+}
+function requiredId(value, field) {
+    const normalized = String(value ?? "").trim();
+    if (!/^\d+$/.test(normalized)) {
+        throw new Error(`${field} 必须是数字 ID。`);
+    }
+    return normalized;
+}
+function numericValue(value) {
+    const numeric = Number(value);
+    return Number.isSafeInteger(numeric) ? numeric : value;
+}
+function requiredVersion(value) {
+    const normalized = value === undefined ? 1 : Number(value);
+    if (!Number.isInteger(normalized) || normalized < 0) {
+        throw new Error("version 必须是非负整数。");
+    }
+    return normalized;
+}
+function requiredInteger(value, field) {
+    const normalized = Number(value);
+    if (!Number.isInteger(normalized)) {
+        throw new Error(`${field} 必须是整数。`);
+    }
+    return normalized;
+}
+function requiredBoolean(value, field) {
+    if (typeof value !== "boolean") {
+        throw new Error(`${field} 必须是布尔值。`);
+    }
+    return value;
+}
+function requiredSegment(value, field) {
+    const normalized = String(value ?? "").trim();
+    if (!/^[A-Za-z0-9_-]{1,32}$/.test(normalized)) {
+        throw new Error(`${field} 必须是安全的路径参数。`);
+    }
+    return normalized;
+}
+function requiredIds(value, field) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error(`${field} 必须是非空 ID 数组。`);
+    }
+    return value.map((item) => numericValue(requiredId(item, field)));
+}
+function safePayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function cleanObject(input) {
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (value !== undefined && value !== null) {
+            output[key] = value;
+        }
+    }
+    return output;
+}