cloudcc-cli 2.2.6 → 2.2.7

package/src/triggers/doc.js

@@ -0,0 +1,342 @@
+/**
+ * triggers 文档统一入口（全量一次性输出）
+ */
+const fs = require("fs");
+const path = require("path");
+
+function generateFullMarkdownDoc() {
+    const lines = [
+        "# CloudCC 触发器开发指南",
+        "",
+        "> 本文档参考 CloudCC 官方「触发器」文档整理而成：[触发器](https://help.cloudcc.cn/product03/hong-fa-qi/)。  ",
+        "> 目标：帮助开发者正确编写、调试和使用触发器，理解触发时机、可用变量、与自定义类/Email/时间工具的协同，以及避免循环调用等常见坑。",
+        "",
+        "---",
+        "",
+        "## 1. 概念与入口",
+        "",
+        "### 1.1 什么是触发器",
+        "",
+        "- 触发器是在特定数据操作事件发生**之前或之后**执行的一段 Java 代码。  ",
+        "- 典型触发时间：",
+        "  - 在对象记录插入数据库之前 / 之后",
+        "  - 在对象记录更新之前 / 之后",
+        "  - 在对象记录删除之前 / 之后",
+        "  - 在审批相关场景（`approval`）中  ",
+        "- 主要用于：",
+        "  - 复杂字段校验（必填、多字段联动、一致性约束）",
+        "  - 自动带值 / 派生字段写入",
+        "  - 与其他对象联动更新",
+        "",
+        "### 1.2 触发器开发入口",
+        "",
+        "两种方式创建触发器：",
+        "",
+        "1. **通过开发者平台**  ",
+        "   - 登录系统 → 右上角头像 → 「开发者平台」（管理员简档可见）  ",
+        "   - 左侧菜单：`扩展 → 触发器 → 新建`",
+        "",
+        "2. **在对象后台设置中创建**  ",
+        "   - 进入目标对象的后台设置（对象管理）  ",
+        "   - 将页面滚动到底部，在「触发器」区域点击「新建`",
+        "",
+        "---",
+        "",
+        "## 2. 触发器配置项与触发时机",
+        "",
+        "### 2.1 基本配置",
+        "",
+        "- **名称**：汉字说明，用于描述触发器完成的功能  ",
+        "- **触发对象**：在哪个对象上执行触发器操作  ",
+        "- **触发时间（Trigger Event）**：决定在什么时机触发",
+        "",
+        "常用触发时间包括：",
+        "",
+        "- `beforeInsert`：新建/复制记录行满足触发条件前执行  ",
+        "- `beforeUpdate`：编辑记录行满足触发条件前执行  ",
+        "- `beforeUpsert`：新建和编辑/复制统一入口前执行  ",
+        "- `beforeDelete`：删除记录前执行  ",
+        "- `afterInsert`：新建/复制记录后执行（可获取记录 ID）  ",
+        "- `afterUpdate`：修改记录后执行  ",
+        "- `afterUpsert`：新建或编辑/复制后执行  ",
+        "- `afterDelete`：删除记录后执行  ",
+        "- `afterInsertCommit`：插入事务提交后执行，**报错不会回滚主事务**  ",
+        "- `afterUpdateCommit`：更新提交后执行，报错不会回滚  ",
+        "- `afterUpsertCommit`：保存提交后执行，报错不会回滚  ",
+        "- `afterDeleteCommit`：删除提交后执行，报错不会回滚  ",
+        "- `approval`：审批流程相关触发",
+        "",
+        "**提示**：  ",
+        "`before*` 阶段通常用于**校验与字段赋值**；`after*` 阶段适合做**关联对象更新、日志记录、异步操作触发**等。",
+        "",
+        "---",
+        "",
+        "## 3. 触发器中可用变量与基础语法",
+        "",
+        "### 3.1 可直接使用的变量",
+        "",
+        "- `(UserInfo) userInfo`：当前操作用户信息  ",
+        "- `(Map) record_new`：当前记录的**最新值**（新建/修改后）  ",
+        "- `(Map) record_old`：当前记录的**旧值**（修改前），在 `insert` 场景通常为 `null`  ",
+        "- `trigger`：触发器上下文对象，可用于添加错误提示等",
+        "",
+        "### 3.2 常用语法与含义",
+        "",
+        "| 语法                                   | 返回值   | 含义                               |",
+        "|----------------------------------------|----------|------------------------------------|",
+        "| `record_new.get(\"字段API\")`            | String   | 获取记录中字段的最新值            |",
+        "| `record_new.put(\"字段API\", \"字段值\")`  | void     | 为记录的某字段赋值                |",
+        "| `record_old.get(\"字段API\")`            | String   | 获取记录中字段的前一个值          |",
+        "| `record_old == null`                   | boolean  | 在 `beforeUpsert/afterUpsert` 中识别是否为新建 |",
+        "| `trigger.addErrorMessage(\"提示内容\")`  | void     | 在保存前用于提示并中止保存        |",
+        "",
+        "**提示**：  ",
+        "字段名使用**字段 API 名称**（如 `project_manager`、`start_date`），自定义字段一般以 `__c` 结尾。",
+        "",
+        "---",
+        "",
+        "## 4. 常见案例",
+        "",
+        "### 4.1 案例 1：字段联动带值（查询赋值）",
+        "",
+        "**需求**  ",
+        "在项目对象中，将当前项目经理的邮箱自动带入本对象的 `email` 字段。  ",
+        "",
+        "**触发事件**：`beforeUpsert`",
+        "",
+        "**代码示例**",
+        "",
+        "```java",
+        "String managerId = record_new.get(\"project_manager\") == null ? \"\" : record_new.get(\"project_manager\") + \"\"; // 新值",
+        "String managerId_old = record_old == null || record_old.get(\"project_manager\") == null ? \"\" : record_old.get(\"project_manager\") + \"\"; // 旧值",
+        "",
+        "// 项目经理字段新值和老值不相同时判定为该字段值发生改变，需重新查询用户表获取邮箱带到本记录中",
+        "if (!managerId.equals(managerId_old)) {",
+        "  List<CCObject> userlist = cquery(\"User\", \"id='\" + managerId + \"'\");",
+        "  if (userlist.size() > 0) {",
+        "    String email = userlist.get(0).get(\"email\") == null ? \"\" : userlist.get(0).get(\"email\") + \"\";",
+        "    record_new.put(\"email\", email);",
+        "  }",
+        "}",
+        "```",
+        "",
+        "要点：",
+        "- 使用 `record_new` / `record_old` 比较判断字段是否变更，**避免无谓查询与写入**。",
+        "- 查询用户对象时使用 `cquery(\"User\", ...)`。",
+        "",
+        "### 4.2 案例 2：复杂必填校验",
+        "",
+        "**需求**  ",
+        "当项目经理不为空时，项目开始日期与结束日期必填，否则不允许保存。",
+        "",
+        "**触发时间**：`beforeUpsert`",
+        "",
+        "**代码示例**",
+        "",
+        "```java",
+        "String managerId = record_new.get(\"project_manager\") == null ? \"\" : record_new.get(\"project_manager\") + \"\"; // 项目经理",
+        "String start_date = record_new.get(\"start_date\") == null ? \"\" : record_new.get(\"start_date\") + \"\";         // 项目开始日期",
+        "String end_date = record_new.get(\"end_date\") == null ? \"\" : record_new.get(\"end_date\") + \"\";               // 项目结束日期",
+        "",
+        "if (!\"\".equals(managerId) && (\"\".equals(start_date) || \"\".equals(end_date))) {",
+        "   trigger.addErrorMessage(\"请填写项目开始日期及项目结束日期\");",
+        "}",
+        "```",
+        "",
+        "要点：",
+        "- 通过 `trigger.addErrorMessage` 阻断保存并提示用户。",
+        "- 适合放在 `beforeInsert` / `beforeUpdate` / `beforeUpsert` 等阶段。",
+        "",
+        "---",
+        "",
+        "## 5. 进阶用法与注意事项",
+        "",
+        "### 5.1 触发器可直接引用的参数",
+        "",
+        "- `UserInfo userInfo`：当前操作用户  ",
+        "- `Map record_new` / `Map record_old`",
+        "",
+        "取字段值时直接使用字段 API 名称：",
+        "",
+        "```java",
+        "String name = record_new.get(\"name\") == null ? \"\" : record_new.get(\"name\") + \"\";",
+        "```",
+        "",
+        "### 5.2 循环调用限制",
+        "",
+        "触发器之间可以间接导致**循环调用**，例如：",
+        "- 在客户对象的 `update` 触发器中更新业务机会  ",
+        "- 在业务机会对象的 `update` 触发器中又更新客户（再次触发客户的 `update` 触发器）  ",
+        "",
+        "如果在触发器中不加条件控制，可能形成无限循环。平台限制：",
+        "- **最多允许 3 次循环调用**  ",
+        "- 超过 3 次系统会报错提示并终止执行",
+        "",
+        "建议：",
+        "- 在跨对象更新时增加「状态字段」或「字段变更判断」作为保护条件  ",
+        "- 避免在 A 的触发器中无条件更新 B，同时在 B 的触发器中又无条件更新 A  ",
+        "- 将复杂联动逻辑尽量下沉到自定义类中集中处理",
+        "",
+        "### 5.3 触发器中发送邮件通知",
+        "",
+        "触发器可以使用 `SendEmail` 发送系统邮件：",
+        "",
+        "```java",
+        "SendEmail sendEmail = new SendEmail(userInfo);",
+        "",
+        "// 直接发送邮件",
+        "sendEmail.sendMailFromSystem(",
+        "  new String[]{\"to@example.com\"},     // 收件人",
+        "  new String[]{\"cc@example.com\"},     // 抄送",
+        "  new String[]{\"bcc@example.com\"},    // 密送",
+        "  \"邮件主题\",",
+        "  \"邮件内容\",",
+        "  true                                // 是否文本邮件",
+        ");",
+        "",
+        "// 使用邮件模板发送",
+        "sendEmail.sendEmailNew(",
+        "  \"emailTemplateId\",",
+        "  new String[]{\"to@example.com\"},",
+        "  new String[]{\"cc@example.com\"},",
+        "  new String[]{\"bcc@example.com\"},",
+        "  record_new.get(\"id\") + \"\"           // 关联记录 ID",
+        ");",
+        "```",
+        "",
+        "### 5.4 获取邮件模板内容",
+        "",
+        "```java",
+        "/**",
+        " * lang：语言",
+        " * emailtemplateid：邮件模板ID",
+        " * id：记录id（可选）",
+        " */",
+        "Map<String, String> m = this.getMessageByTemplateId(lang, emailtemplateid, record_new.get(\"id\") + \"\");",
+        "",
+        "// 邮件标题",
+        "String subject = m.get(\"subject\");",
+        "// 邮件内容",
+        "String content = m.get(\"context\");",
+        "// 邮件是否为文本形式",
+        "String isText = m.get(\"istext\");",
+        "```",
+        "",
+        "可以先获取模板内容，再根据业务需要调整后发送。",
+        "",
+        "### 5.5 TimeUtil：多时区时间支持",
+        "",
+        "与自定义类中用法相同，触发器也应使用 `TimeUtil` 来处理与时区相关的时间：",
+        "",
+        "- 获取当前时间（按用户时区）：",
+        "",
+        "```java",
+        "TpSysTask task = new TpSysTask();",
+        "task.setBeginTime(TimeUtil.getNowDate(userInfo));",
+        "```",
+        "",
+        "- 获取带时区的 `SimpleDateFormat`：",
+        "",
+        "```java",
+        "SimpleDateFormat myDateFormat = TimeUtil.getSimpleDateFormat(\"yyyy-MM-dd\", userInfo);",
+        "```",
+        "",
+        "- 获取带时区的 `Calendar`：",
+        "",
+        "```java",
+        "Calendar cal = TimeUtil.getCalendar(userInfo);",
+        "```",
+        "",
+        "---",
+        "",
+        "## 6. 与 CCService / 自定义类的协同",
+        "",
+        "### 6.1 在触发器中使用 CCService",
+        "",
+        "触发器中同样可以实例化并使用 `CCService` 进行增删改查：",
+        "",
+        "```java",
+        "CCService cs = new CCService((UserInfo) userInfo);",
+        "",
+        "// 示例：根据当前记录字段查询机会",
+        "String accountId = record_new.get(\"khmc__c\") == null ? \"\" : record_new.get(\"khmc__c\") + \"\";",
+        "if (!\"\".equals(accountId)) {",
+        "  List<CCObject> opps = cs.cquery(",
+        "    \"Opportunity\",",
+        "    \"khmc__c = '\" + accountId + \"'\",",
+        "    \"jine__c desc\"",
+        "  );",
+        "  // TODO: 根据查询结果执行相应逻辑",
+        "}",
+        "```",
+        "",
+        "具体 `CCService` 能力详见 `custom-class-dev.md`。",
+        "",
+        "### 6.2 将复杂逻辑下沉到自定义类",
+        "",
+        "推荐模式：",
+        "",
+        "1. 触发器中只负责：",
+        "   - 判断是否需要执行逻辑（字段是否变化、状态是否满足、避免循环等）",
+        "   - 准备必需参数（如 `userInfo`、`record_new` / `record_old` 等）",
+        "2. 将主要业务逻辑封装到自定义类方法中：",
+        "",
+        "```java",
+        "// 触发器中",
+        "if (/* 条件满足 */) {",
+        "  new ProjectService(userInfo).handleAfterUpdate(record_old, record_new);",
+        "}",
+        "```",
+        "",
+        "好处：",
+        "- 逻辑集中、可复用、易测试  ",
+        "- 触发器代码保持精简，可读性更高",
+        "",
+        "---",
+        "",
+        "## 7. 触发器开发 Checklist",
+        "",
+        "- [ ] 已选择正确的**触发对象**与**触发时间**（before/after/commit/approval）  ",
+        "- [ ] 校验逻辑集中在 `before*` 阶段，并通过 `trigger.addErrorMessage` 给出清晰提示  ",
+        "- [ ] 使用 `record_new` / `record_old` 判断字段是否变化，避免不必要的数据库操作  ",
+        "- [ ] 涉及跨对象更新时，已经考虑并避免循环调用（尤其是双向更新）  ",
+        "- [ ] 发送邮件时使用 `SendEmail` / 模板，且确认模板与收件人配置正确  ",
+        "- [ ] 与时间相关逻辑使用 `TimeUtil`，避免跨时区错误  ",
+        "- [ ] 复杂业务逻辑拆分到自定义类中，通过触发器调用，触发器本身保持简洁  ",
+        "- [ ] 已在测试环境完整验证：新建、编辑、删除、审批等全场景，确认不会出现循环触发或异常回滚问题  ",
+        "",
+    ];
+
+    const base = lines.join("\n");
+    const sdkPath = path.join(__dirname, "..", "api", "backend-sdk-java.md");
+    let sdkContent = "";
+    try {
+        sdkContent = fs.readFileSync(sdkPath, "utf8");
+    } catch (e) {
+        sdkContent = `# CloudCC 后端 SDK（Java）使用指南\n\n（未找到文件：${sdkPath}）\n`;
+    }
+
+    return [
+        base,
+        "",
+        "---",
+        "",
+        "## 附录：后端 SDK（Java）速查",
+        "",
+        "> 来源：`src/api/backend-sdk-java.md`",
+        "",
+        sdkContent.trim(),
+        "",
+    ].join("\n");
+}
+
+function doc() {
+    const content = generateFullMarkdownDoc();
+    console.log(content);
+    return content;
+}
+
+// 兼容旧调用方：统一返回全量文档
+doc.getEditGuide = doc;
+
+module.exports = doc;

package/src/triggers/index.js

@@ -5,7 +5,12 @@ cc.pull = require("./pull")
 cc.get = require("./get")
 cc.pullList = require("./pullList")
 cc.detail = require("./detail")
+cc.doc = require("./doc")
 function Classes(action, argvs) {
+  if (action === "detail") {
+    cc[action](argvs[2], argvs[3]);
+    return;
+  }
   cc[action](argvs)
 }
 

package/test/application.cli.test.js

@@ -0,0 +1,30 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const { exec } = require("node:child_process");
+const { promisify } = require("node:util");
+
+const execAsync = promisify(exec);
+const repoRoot = path.resolve(__dirname, "..");
+
+function quoteArg(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+async function runCc(args) {
+  const cmd = `npx --prefix "${repoRoot}" cc ${args.map(quoteArg).join(" ")}`;
+  return execAsync(cmd, { cwd: repoRoot });
+}
+
+test("应用管理流程：创建 application", async () => {
+  const appName = `TestApp${Date.now()}`;
+  const appCode = `test_app_${Date.now()}`;
+
+  const { stdout, stderr } = await runCc(["create", "application", repoRoot, appName, appCode]);
+  const out = `${stdout}\n${stderr}`.trim();
+
+  // src/application/create.js 成功时会输出 `Success！`
+  assert.match(out, /Success|成功/i, "create application 应输出成功信息");
+  console.error(`\n[application-test] 已创建应用: ${appName} (code=${appCode})`);
+});
+

package/test/classes.cli.test.js

@@ -0,0 +1,121 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const { exec } = require("node:child_process");
+const { promisify } = require("node:util");
+
+const execAsync = promisify(exec);
+const repoRoot = path.resolve(__dirname, "..");
+
+function quoteArg(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+async function runCc(args) {
+  const cmd = `npx --prefix "${repoRoot}" cc ${args.map(quoteArg).join(" ")}`;
+  return execAsync(cmd, { cwd: repoRoot });
+}
+
+test("类管理流程：创建→doc→发布→拉取→线上详情→列表→批量拉取前2个→清空classes文件夹", async (t) => {
+  const className = `CCbbbbbbFlow${Date.now()}`;
+  const classDir = path.join(repoRoot, "classes", className);
+  const configPath = path.join(classDir, "config.json");
+  const javaPath = path.join(classDir, `${className}.java`);
+  const classesRoot = path.join(repoRoot, "classes");
+
+  let publishedId = null;
+  let topIds = [];
+
+  t.test("1) 创建类", async () => {
+    await runCc(["create", "classes", className]);
+
+    const javaTestPath = path.join(classDir, `${className}Test.java`);
+    assert.equal(fs.existsSync(classDir), true);
+    assert.equal(fs.existsSync(javaPath), true);
+    assert.equal(fs.existsSync(javaTestPath), true);
+    assert.equal(fs.existsSync(configPath), true);
+
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    assert.equal(config.name, className);
+  });
+
+  t.test("2) 获取 doc（classes overview）", async () => {
+    const { stdout } = await runCc(["doc", "classes", "overview"]);
+    assert.match(stdout, /CloudCC 类编辑知识库/);
+  });
+
+  t.test("3) 发布类（publish，写回 config.id）", async () => {
+    await runCc(["publish", "classes", className]);
+    const configAfterPublish = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    publishedId = configAfterPublish.id || null;
+    assert.ok(publishedId, "publish 后应写入 config.id");
+  });
+
+  t.test("4) 拉取类（pull：覆盖 SOURCE 区域）", async () => {
+    const localJava = fs.readFileSync(javaPath, "utf8");
+    const modifiedJava = localJava.replace(
+      /\/\/ @SOURCE_CONTENT_START[\s\S]*?\/\/ @SOURCE_CONTENT_END/,
+      "// @SOURCE_CONTENT_START\npublic String localOnly(){ return \"LOCAL_ONLY\"; }\n// @SOURCE_CONTENT_END"
+    );
+    fs.writeFileSync(javaPath, modifiedJava, "utf8");
+
+    await runCc(["pull", "classes", className]);
+    const javaAfterPull = fs.readFileSync(javaPath, "utf8");
+    assert.ok(!javaAfterPull.includes("LOCAL_ONLY"), "pull 后应使用远端源码替换本地标记内容");
+  });
+
+  t.test("5) 查询线上类详情（detail：仅使用 id，不走本地）", async () => {
+    // detail(name,id) 内部逻辑：name 为空会跳过本地优先，从服务器查询 id
+    assert.ok(publishedId, "发布后应有 publishedId");
+    await assert.doesNotReject(() => runCc(["detail", "classes", "", publishedId]));
+  });
+
+  t.test("6) get 获取线上类列表（取前2个类 id）", async () => {
+    const listQuery = encodeURI(
+      JSON.stringify({
+        shownum: "2000",
+        showpage: "1",
+        fid: "",
+        sname: "",
+        rptcond: "",
+        rptorder: "",
+      })
+    );
+
+    const { stdout } = await runCc(["get", "classes", listQuery]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get classes 应返回数组");
+
+    // 保存前2个 id
+    topIds = list.slice(0, 2).map((x) => x.id).filter(Boolean);
+    assert.ok(topIds.length >= 1, "线上类列表至少应包含 1 个 id");
+  });
+
+  t.test("7) 批量拉取前2个类（pullList）", async () => {
+    assert.ok(topIds.length >= 1, "pullList 需要至少 1 个线上类 id");
+
+    const beforeCount = fs.existsSync(classesRoot)
+      ? fs.readdirSync(classesRoot).filter((n) => fs.statSync(path.join(classesRoot, n)).isDirectory()).length
+      : 0;
+
+    for (const id of topIds) {
+      await runCc(["pullList", "classes", id, repoRoot]);
+    }
+
+    const afterCount = fs.readdirSync(classesRoot).filter((n) =>
+      fs.statSync(path.join(classesRoot, n)).isDirectory()
+    ).length;
+    assert.ok(afterCount >= beforeCount, "pullList 之后 classes 目录应存在/可用");
+  });
+
+  t.test("8) 清空 classes 文件夹", async () => {
+    if (fs.existsSync(classesRoot)) {
+      fs.rmSync(classesRoot, { recursive: true, force: true });
+    }
+    fs.mkdirSync(classesRoot, { recursive: true });
+    const remain = fs.readdirSync(classesRoot);
+    assert.equal(remain.length, 0);
+    console.error("");
+  });
+});

package/test/fields.cli.test.js

@@ -0,0 +1,69 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const { exec } = require("node:child_process");
+const { promisify } = require("node:util");
+
+const execAsync = promisify(exec);
+const repoRoot = path.resolve(__dirname, "..");
+
+function quoteArg(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+async function runCc(args) {
+  const cmd = `npx --prefix "${repoRoot}" cc ${args.map(quoteArg).join(" ")}`;
+  return execAsync(cmd, { cwd: repoRoot });
+}
+
+test("字段管理流程：获取对象列表→create 字段→get 字段列表", async (t) => {
+  let objPrefix = null;
+  let objId = null;
+  let objName = null;
+  const fieldLabel = `AutoField_${Date.now()}`;
+
+  t.test("1) 获取对象列表（取第一个对象的 id 和 objprefix）", async () => {
+    // 只取自定义对象，避免标准对象在部分环境下字段接口异常
+    const { stdout } = await runCc(["get", "object", repoRoot, "custom"]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list) || (list && typeof list === "object"), "get object 应返回列表或对象");
+    const arr = Array.isArray(list) ? list : (list.objList || list.data || []);
+    assert.ok(arr.length > 0, "自定义对象列表应非空");
+
+    const first = arr[0];
+    objPrefix = first.objprefix || first.prefix || "account";
+    objId = first.id || first.objid || null;
+    objName = first.label || first.schemetableName || "UnknownObject";
+
+    assert.ok(objPrefix, "应有可用的 objprefix");
+    assert.ok(objId, "应有可用的对象 id 用于创建字段");
+
+    console.error(`\n[fields-test] 目标对象: ${objName} (prefix=${objPrefix}, id=${objId})`);
+  });
+
+  t.test("2) create 创建一个文本字段（S）", async () => {
+    assert.ok(objId, "需要对象 id");
+    // create fields 调用约定：cc create fields <path> <fieldType> <objid> <nameLabel> [...]
+    const { stdout, stderr } = await runCc(["create", "fields", repoRoot, "S", objId, fieldLabel]);
+    // create fields 会通过 console.error 输出创建结果（见 src/fields/create.js）
+    assert.match(
+      `${stdout}\n${stderr}`,
+      /Field created successfully|✓\s*Field created successfully/i,
+      "create fields 应输出创建成功信息"
+    );
+    console.error(`[fields-test] 已创建字段: ${fieldLabel}`);
+  });
+
+  t.test("3) get 获取指定对象的字段列表，并尽量校验新字段", async () => {
+    assert.ok(objPrefix, "需要 objprefix");
+    const { stdout } = await runCc(["get", "fields", repoRoot, objPrefix]);
+    const res = JSON.parse(stdout.trim());
+    assert.ok(res && (res.stdFields !== undefined || res.cusFields !== undefined), "get fields 应返回 stdFields 或 cusFields");
+    if (res.stdFields) assert.ok(Array.isArray(res.stdFields), "stdFields 应为数组");
+    if (res.cusFields) assert.ok(Array.isArray(res.cusFields), "cusFields 应为数组");
+
+    // 尽量校验新字段是否已出现（不强制）
+    const allCus = Array.isArray(res.cusFields) ? res.cusFields : [];
+    const hit = allCus.some((f) => f.fieldname === fieldLabel || f.apiname?.includes("_custom_s_field"));
+  });
+});

package/test/mcp.cli.test.js

@@ -0,0 +1,21 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const fs = require("node:fs");
+
+const repoRoot = path.resolve(__dirname, "..");
+
+test("MCP 模块：服务可加载、bin 存在", async (t) => {
+  t.test("1) 加载 MCP 服务模块", async () => {
+    const mcpServer = require(path.join(repoRoot, "src/mcp/index.js"));
+    assert.ok(mcpServer, "MCP 模块应导出服务实例");
+    assert.ok(typeof mcpServer === "object", "导出应为对象");
+  });
+
+  t.test("2) bin/mcp.js 存在且可读", async () => {
+    const binPath = path.join(repoRoot, "bin/mcp.js");
+    assert.ok(fs.existsSync(binPath), "bin/mcp.js 应存在");
+    const content = fs.readFileSync(binPath, "utf8");
+    assert.match(content, /mcp|MCP|StdioServerTransport/, "bin/mcp.js 应引用 MCP 相关逻辑");
+  });
+});

package/test/menu.cli.test.js

@@ -0,0 +1,41 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const { exec } = require("node:child_process");
+const { promisify } = require("node:util");
+
+const execAsync = promisify(exec);
+const repoRoot = path.resolve(__dirname, "..");
+
+function quoteArg(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+async function runCc(args) {
+  const cmd = `npx --prefix "${repoRoot}" cc ${args.map(quoteArg).join(" ")}`;
+  return execAsync(cmd, { cwd: repoRoot });
+}
+
+test("菜单管理流程：获取对象列表→create menu object", async (t) => {
+  let objectId = null;
+  let objectName = null;
+
+  t.test("1) 获取自定义对象列表（取第一个自定义对象 id 用于创建菜单）", async () => {
+    const { stdout } = await runCc(["get", "object", repoRoot, "custom"]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get object custom 应返回数组");
+    if (list.length > 0 && list[0].id) {
+      objectId = list[0].id;
+      objectName = list[0].label || list[0].schemetableName || list[0].objname || null;
+    }
+    assert.ok(objectId, "线上至少应有一个自定义对象 id 用于创建菜单");
+    console.error(`\n[menu-test] 目标自定义对象: ${objectName || "Unknown"} (id=${objectId})`);
+  });
+
+  t.test("2) 创建对象类型菜单（create menu object）", async () => {
+    assert.ok(objectId, "需要 objectId");
+    await assert.doesNotReject(() =>
+      runCc(["create", "menu", "object", repoRoot, objectId, "CC测试菜单Tab"])
+    );
+  });
+});