cloudcc-cli 2.2.5 → 2.2.7

package/test/object.cli.test.js

@@ -0,0 +1,64 @@
+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("对象管理流程：get 对象列表→create 对象→get 列表校验", async (t) => {
+  const objectLabel = `TestObj${Date.now()}`;
+  const labelNeedle = "testobj";
+  let createdSlugHit = false;
+
+  t.test("1) create 创建自定义对象", async () => {
+    await assert.doesNotReject(() => runCc(["create", "object", repoRoot, objectLabel]));
+    console.error(`\n[object-test] 已创建自定义对象 label: ${objectLabel}`);
+  });
+
+  t.test("2) get 获取标准对象列表（standard）", async () => {
+    const { stdout } = await runCc(["get", "object", repoRoot, "standard"]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get object standard 应返回数组");
+    assert.ok(list.length > 0, "标准对象列表应非空");
+    // 标准对象列表不要求包含新建自定义对象
+  });
+
+  t.test("3) get 获取自定义对象列表（custom）并校验包含新对象", async () => {
+    const { stdout } = await runCc(["get", "object", repoRoot, "custom"]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get object custom 应返回数组");
+    assert.ok(list.length > 0, "自定义对象列表应非空");
+
+    createdSlugHit = list.some((o) => {
+      const s = `${o.schemetableName || ""}`.toLowerCase();
+      const l = `${o.label || o.objname || ""}`.toLowerCase();
+      return s.includes(labelNeedle) || l.includes(labelNeedle);
+    });
+    assert.ok(createdSlugHit, "custom 列表应包含刚创建的自定义对象（按 testobj 关键字匹配）");
+  });
+
+  t.test("4) get 获取全部对象列表（both / 默认）并校验包含新对象", async () => {
+    const { stdout } = await runCc(["get", "object", repoRoot]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get object（默认）应返回数组");
+    assert.ok(list.length > 0, "全部对象列表应非空");
+
+    const found = list.some((o) => {
+      const s = `${o.schemetableName || ""}`.toLowerCase();
+      const l = `${o.label || o.objname || ""}`.toLowerCase();
+      return s.includes(labelNeedle) || l.includes(labelNeedle);
+    });
+    assert.ok(found || createdSlugHit, "both 列表应包含刚创建的自定义对象");
+  });
+});

package/test/plugin.cli.test.js

@@ -0,0 +1,109 @@
+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, "..");
+const pluginsRoot = path.join(repoRoot, "plugins");
+
+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→发布→拉取→详情→列表→清空 plugins 文件夹", async (t) => {
+  const pluginName = `CCPlugin${Date.now()}`;
+  const pluginDir = path.join(pluginsRoot, pluginName);
+  const configPath = path.join(pluginDir, "config.json");
+  const vuePath = path.join(pluginDir, `${pluginName}.vue`);
+  let publishedId = null;
+  let publishOk = false;
+  let pulledPluginName = null;
+  let pulledPluginId = null;
+
+  t.test("1) 创建组件", async () => {
+    await runCc(["create", "plugin", pluginName]);
+
+    assert.equal(fs.existsSync(pluginDir), true);
+    assert.equal(fs.existsSync(configPath), true);
+    assert.equal(fs.existsSync(vuePath), true);
+
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    assert.ok(config.component && config.component.includes(pluginName));
+  });
+
+  t.test("2) 获取 doc（plugin overview）", async () => {
+    const { stdout } = await runCc(["doc", "plugin", "overview"]);
+    assert.ok(stdout.length > 0, "doc plugin 应有输出");
+  });
+
+  t.test("3) 发布组件（publish：以输出判断成功）", async () => {
+    const { stdout, stderr } = await runCc(["publish", "plugin", pluginName]);
+    const out = `${stdout}\n${stderr}`.trim();
+    // 注意：src/plugin/publish1.js 使用 child_process.exec 的回调触发上传，
+    // 在 CLI 进程退出前不一定能等到 build/upload 完成，因此这里用“编译阶段成功”作为发布成功的判定。
+    publishOk = /Compilation Successful|Compilation Successful！|Success|Successful|成功|returnCode\s*[:=]\s*200|200/i.test(out);
+    assert.ok(publishOk, "publish 应至少输出编译成功或发布成功信息");
+
+    // 兼容：部分环境不会写回 config.id，因此这里不再强依赖 publishedId
+    const configAfterPublish = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    publishedId = configAfterPublish.id || null;
+  });
+
+  t.test("4) 拉取组件（先 get 列表，再按 id pull）", async () => {
+    // 先拿线上列表，再选择第一个可用的 id 拉取（不依赖 publish 是否写回 id）
+    const { stdout } = await runCc(["get", "plugin", repoRoot]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get plugin 应返回数组");
+    assert.ok(list.length > 0, "线上组件列表应非空");
+
+    const first = list.find((x) => x && x.id) || null;
+    assert.ok(first && first.id, "应能从列表中取到组件 id");
+    pulledPluginId = first.id;
+
+    // pull 支持通过 id 拉取并自动创建本地目录
+    await runCc(["pull", "plugin", pulledPluginId, repoRoot]);
+
+    // 通过本地目录判断拉取是否成功：pull.js 会归一化名称（去掉 component- 前缀）
+    const guessName =
+      (first.name && String(first.name)) ||
+      (first.component && String(first.component)) ||
+      null;
+    pulledPluginName = guessName ? guessName.replace(/^component-/, "") : null;
+    assert.ok(pulledPluginName, "应能从列表推断出拉取后的本地插件目录名");
+
+    const pulledDir = path.join(pluginsRoot, pulledPluginName);
+    assert.ok(fs.existsSync(pulledDir), "pull 后应生成本地插件目录");
+    assert.ok(fs.existsSync(path.join(pulledDir, "config.json")), "pull 后应生成 config.json");
+  });
+
+  t.test("5) 查询组件详情（detail：本地 name）", async () => {
+    // 优先对拉取到的插件做 detail（确保链路：get -> pull -> detail）
+    const pulledDir = path.join(pluginsRoot, pulledPluginName);
+    assert.ok(pulledPluginName, "需要 pulledPluginName");
+    assert.ok(fs.existsSync(pulledDir), "pull 后本地目录应存在");
+    await assert.doesNotReject(() => runCc(["detail", "plugin", pulledPluginName, "", repoRoot]));
+  });
+
+  t.test("6) get 获取线上组件列表", async () => {
+    const { stdout } = await runCc(["get", "plugin", repoRoot]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get plugin 应返回数组");
+  });
+
+  t.test("7) 清空 plugins 文件夹", async () => {
+    if (fs.existsSync(pluginsRoot)) {
+      fs.rmSync(pluginsRoot, { recursive: true, force: true });
+    }
+    fs.mkdirSync(pluginsRoot, { recursive: true });
+    const remain = fs.readdirSync(pluginsRoot);
+    assert.equal(remain.length, 0);
+  });
+});

package/test/script.cli.test.js

@@ -0,0 +1,101 @@
+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, "..");
+const scriptRoot = path.join(repoRoot, "script");
+
+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个→清空 script 文件夹", async (t) => {
+  const objName = "Account";
+  const scriptName = `TestScript${Date.now()}`;
+  const namePath = `${objName}/${scriptName}`;
+  const scriptDir = path.join(scriptRoot, objName, scriptName);
+  const configPath = path.join(scriptDir, "config.json");
+  const jsPath = path.join(scriptDir, `${scriptName}.js`);
+  let topIds = [];
+
+  t.test("1) 创建客户端脚本", async () => {
+    const body = encodeURI(JSON.stringify({ objName, scriptName }));
+    await runCc(["create", "script", body]);
+
+    assert.equal(fs.existsSync(scriptDir), true);
+    assert.equal(fs.existsSync(configPath), true);
+    assert.equal(fs.existsSync(jsPath), true);
+
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    assert.equal(config.scriptName, scriptName);
+    assert.equal(config.objName, objName);
+  });
+
+  t.test("2) 获取 doc（script overview）", async () => {
+    const { stdout } = await runCc(["doc", "script", "overview"]);
+    assert.match(stdout, /客户端脚本|CCDK|编辑指南/i);
+  });
+
+  t.test("3) 发布脚本（publish，写回 config.id）", async () => {
+    await runCc(["publish", "script", namePath]);
+    const configAfterPublish = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    assert.ok(configAfterPublish.id, "publish 后应写入 config.id");
+  });
+
+  t.test("4) 拉取脚本（pull：覆盖本地）", async () => {
+    const localJs = fs.readFileSync(jsPath, "utf8");
+    const modifiedJs = localJs + "\n// LOCAL_ONLY";
+    fs.writeFileSync(jsPath, modifiedJs, "utf8");
+
+    await runCc(["pull", "script", namePath, repoRoot]);
+    const jsAfterPull = fs.readFileSync(jsPath, "utf8");
+    assert.ok(!jsAfterPull.includes("LOCAL_ONLY"), "pull 后应使用远端内容覆盖本地");
+  });
+
+  t.test("5) 查询线上脚本详情（detail：仅使用 id 或 namePath）", async () => {
+    await assert.doesNotReject(() => runCc(["detail", "script", namePath, "", repoRoot]));
+  });
+
+  t.test("6) get 获取线上脚本列表（取前2个 id）", async () => {
+    const listQuery = encodeURI(JSON.stringify({ pageNo: 1, pageSize: 20, condition: {} }));
+    const { stdout } = await runCc(["get", "script", listQuery, repoRoot]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get script 应返回数组");
+    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(scriptRoot)
+      ? fs.readdirSync(scriptRoot).filter((n) => fs.statSync(path.join(scriptRoot, n)).isDirectory()).length
+      : 0;
+
+    for (const id of topIds) {
+      await runCc(["pullList", "script", id, repoRoot]);
+    }
+
+    const afterCount = fs.existsSync(scriptRoot)
+      ? fs.readdirSync(scriptRoot).filter((n) => fs.statSync(path.join(scriptRoot, n)).isDirectory()).length
+      : 0;
+    assert.ok(afterCount >= beforeCount, "pullList 之后 script 目录应存在/可用");
+  });
+
+  t.test("8) 清空 script 文件夹", async () => {
+    if (fs.existsSync(scriptRoot)) {
+      fs.rmSync(scriptRoot, { recursive: true, force: true });
+    }
+    fs.mkdirSync(scriptRoot, { recursive: true });
+    const remain = fs.readdirSync(scriptRoot);
+    assert.equal(remain.length, 0);
+  });
+});

package/test/timer.cli.test.js

@@ -0,0 +1,107 @@
+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, "..");
+const scheduleRoot = path.join(repoRoot, "schedule");
+
+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("定时任务管理流程：创建→发布→拉取→线上详情→列表→批量拉取前2个→清空 schedule 文件夹", async (t) => {
+  const timerName = `CCTimer${Date.now()}`;
+  const timerDir = path.join(scheduleRoot, timerName);
+  const configPath = path.join(timerDir, "config.json");
+  const javaPath = path.join(timerDir, `${timerName}.java`);
+  let publishedId = null;
+  let topIds = [];
+
+  t.test("1) 创建定时任务", async () => {
+    await runCc(["create", "timer", timerName]);
+
+    assert.equal(fs.existsSync(timerDir), true);
+    assert.equal(fs.existsSync(configPath), true);
+    assert.equal(fs.existsSync(javaPath), true);
+
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    assert.equal(config.name, timerName);
+  });
+
+  t.test("2) 发布定时任务（publish，写回 config.id）", async () => {
+    await runCc(["publish", "timer", timerName]);
+    const configAfterPublish = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    publishedId = configAfterPublish.id || null;
+    assert.ok(publishedId, "publish 后应写入 config.id");
+  });
+
+  t.test("3) 拉取定时任务（pull：覆盖 SOURCE 区域）", async () => {
+    const localJava = fs.readFileSync(javaPath, "utf8");
+    const modifiedJava = localJava.replace(
+      /\/\/ @SOURCE_CONTENT_START[\s\S]*?\/\/ @SOURCE_CONTENT_END/,
+      "// @SOURCE_CONTENT_START\nSystem.out.print(\"LOCAL_ONLY\");\n// @SOURCE_CONTENT_END"
+    );
+    fs.writeFileSync(javaPath, modifiedJava, "utf8");
+
+    await runCc(["pull", "timer", timerName]);
+    const javaAfterPull = fs.readFileSync(javaPath, "utf8");
+    assert.ok(!javaAfterPull.includes("LOCAL_ONLY"), "pull 后应使用远端源码替换本地标记内容");
+  });
+
+  t.test("4) 查询线上定时任务详情（detail：仅使用 id）", async () => {
+    assert.ok(publishedId, "发布后应有 publishedId");
+    await assert.doesNotReject(() => runCc(["detail", "timer", "", publishedId]));
+  });
+
+  t.test("5) get 获取线上定时任务列表（取前2个 id）", async () => {
+    const listQuery = encodeURI(
+      JSON.stringify({
+        shownum: "2000",
+        showpage: "1",
+        fid: "",
+        sname: "",
+        rptcond: "",
+        rptorder: "",
+      })
+    );
+    const { stdout } = await runCc(["get", "timer", listQuery, repoRoot]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get timer 应返回数组");
+    topIds = list.slice(0, 2).map((x) => x.id).filter(Boolean);
+    assert.ok(topIds.length >= 1, "线上定时任务列表至少应包含 1 个 id");
+  });
+
+  t.test("6) 批量拉取前2个定时任务（pullList）", async () => {
+    assert.ok(topIds.length >= 1, "pullList 需要至少 1 个线上定时任务 id");
+    const beforeCount = fs.existsSync(scheduleRoot)
+      ? fs.readdirSync(scheduleRoot).filter((n) => fs.statSync(path.join(scheduleRoot, n)).isDirectory()).length
+      : 0;
+
+    for (const id of topIds) {
+      await runCc(["pullList", "timer", id, repoRoot]);
+    }
+
+    const afterCount = fs.readdirSync(scheduleRoot).filter((n) =>
+      fs.statSync(path.join(scheduleRoot, n)).isDirectory()
+    ).length;
+    assert.ok(afterCount >= beforeCount, "pullList 之后 schedule 目录应存在/可用");
+  });
+
+  t.test("7) 清空 schedule 文件夹", async () => {
+    if (fs.existsSync(scheduleRoot)) {
+      fs.rmSync(scheduleRoot, { recursive: true, force: true });
+    }
+    fs.mkdirSync(scheduleRoot, { recursive: true });
+    const remain = fs.readdirSync(scheduleRoot);
+    assert.equal(remain.length, 0);
+  });
+});

package/test/trigger.cli.test.js

@@ -0,0 +1,146 @@
+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, "..");
+const triggersRoot = path.join(repoRoot, "triggers");
+
+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个→清空 triggers 文件夹", async (t) => {
+  let schemetableName = "Account";
+  let targetObjectId = null;
+  let apiname = null;
+  const triggerTime = "beforeInsert";
+  const triggerName = `TestTrigger${Date.now()}`;
+  const namePath = `${schemetableName.toLowerCase()}/${triggerName}`;
+  const triggerDir = path.join(triggersRoot, schemetableName.toLowerCase(), triggerName);
+  const configPath = path.join(triggerDir, "config.json");
+  const javaPath = path.join(triggerDir, `${triggerName}.java`);
+  let topIds = [];
+
+  t.test("1) 获取自定义对象列表（取 schemetableName 用于创建触发器）", async () => {
+    const { stdout } = await runCc(["get", "object", repoRoot, "custom"]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list) && list.length > 0, "get object custom 应返回非空数组");
+    const first = list[0];
+    schemetableName = first.schemetableName || first.label || "Account";
+    targetObjectId = first.id || null;
+    apiname = `NTrigger${Date.now()}`;
+    assert.ok(targetObjectId, "应能拿到自定义对象 id 作为 targetObjectId");
+  });
+
+  t.test("2) 创建触发器", async () => {
+    const body = encodeURI(
+      JSON.stringify({
+        schemetableName,
+        targetObjectId,
+        triggerTime,
+        name: triggerName,
+        apiname,
+      })
+    );
+    await runCc(["create", "triggers", body]);
+
+    const expectedDir = path.join(triggersRoot, schemetableName.toLowerCase(), triggerName);
+    assert.equal(fs.existsSync(expectedDir), true);
+    assert.equal(fs.existsSync(path.join(expectedDir, "config.json")), true);
+    assert.equal(fs.existsSync(path.join(expectedDir, `${triggerName}.java`)), true);
+
+    const config = JSON.parse(fs.readFileSync(path.join(expectedDir, "config.json"), "utf8"));
+    assert.equal(config.name, triggerName);
+    assert.equal(config.apiname, apiname);
+    assert.equal(config.targetObjectId, targetObjectId);
+    assert.equal(config.triggerTime, triggerTime);
+  });
+
+  t.test("3) 获取 doc（triggers overview）", async () => {
+    const { stdout } = await runCc(["doc", "triggers", "overview"]);
+    assert.match(stdout, /触发器|CCTrigger|编辑指南/i);
+  });
+
+  t.test("4) 发布触发器（publish，写回 config.id）", async () => {
+    const namePathForPublish = `${schemetableName.toLowerCase()}/${triggerName}`;
+    await runCc(["publish", "triggers", namePathForPublish]);
+    const configAfterPublish = JSON.parse(
+      fs.readFileSync(path.join(triggersRoot, schemetableName.toLowerCase(), triggerName, "config.json"), "utf8")
+    );
+    assert.ok(configAfterPublish.id, "publish 后应写入 config.id");
+  });
+
+  t.test("5) 拉取触发器（pull：覆盖 SOURCE 区域）", async () => {
+    const triggerPath = path.join(triggersRoot, schemetableName.toLowerCase(), triggerName);
+    const javaPathLocal = path.join(triggerPath, `${triggerName}.java`);
+    const localJava = fs.readFileSync(javaPathLocal, "utf8");
+    const modifiedJava = localJava.replace(
+      /\/\/ @SOURCE_CONTENT_START[\s\S]*?\/\/ @SOURCE_CONTENT_END/,
+      "// @SOURCE_CONTENT_START\nSystem.out.print(\"LOCAL_ONLY\");\n// @SOURCE_CONTENT_END"
+    );
+    fs.writeFileSync(javaPathLocal, modifiedJava, "utf8");
+
+    await runCc(["pull", "triggers", `${schemetableName.toLowerCase()}/${triggerName}`]);
+    const javaAfterPull = fs.readFileSync(javaPathLocal, "utf8");
+    assert.ok(!javaAfterPull.includes("LOCAL_ONLY"), "pull 后应使用远端源码替换本地标记内容");
+  });
+
+  t.test("6) 查询线上触发器详情（detail：仅使用 id）", async () => {
+    const configPathLocal = path.join(triggersRoot, schemetableName.toLowerCase(), triggerName, "config.json");
+    const publishedId = JSON.parse(fs.readFileSync(configPathLocal, "utf8")).id;
+    assert.ok(publishedId, "发布后应有 id");
+    await assert.doesNotReject(() => runCc(["detail", "triggers", "", publishedId]));
+  });
+
+  t.test("7) get 获取线上触发器列表（取前2个 id）", async () => {
+    const listQuery = encodeURI(
+      JSON.stringify({
+        shownum: "2000",
+        showpage: "1",
+        fid: "",
+        sname: "",
+        rptcond: "",
+        rptorder: "",
+      })
+    );
+    const { stdout } = await runCc(["get", "triggers", listQuery, repoRoot]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get triggers 应返回数组");
+    topIds = list.slice(0, 2).map((x) => x.id).filter(Boolean);
+    assert.ok(topIds.length >= 1, "线上触发器列表至少应包含 1 个 id");
+  });
+
+  t.test("8) 批量拉取前2个触发器（pullList）", async () => {
+    assert.ok(topIds.length >= 1, "pullList 需要至少 1 个线上触发器 id");
+    const beforeCount = fs.existsSync(triggersRoot)
+      ? fs.readdirSync(triggersRoot).filter((n) => fs.statSync(path.join(triggersRoot, n)).isDirectory()).length
+      : 0;
+
+    for (const id of topIds) {
+      await runCc(["pullList", "triggers", id, repoRoot]);
+    }
+
+    const afterCount = fs.existsSync(triggersRoot)
+      ? fs.readdirSync(triggersRoot).filter((n) => fs.statSync(path.join(triggersRoot, n)).isDirectory()).length
+      : 0;
+    assert.ok(afterCount >= beforeCount, "pullList 之后 triggers 目录应存在/可用");
+  });
+
+  t.test("9) 清空 triggers 文件夹", async () => {
+    if (fs.existsSync(triggersRoot)) {
+      fs.rmSync(triggersRoot, { recursive: true, force: true });
+    }
+    fs.mkdirSync(triggersRoot, { recursive: true });
+    const remain = fs.readdirSync(triggersRoot);
+    assert.equal(remain.length, 0);
+  });
+});

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-    "java.configuration.updateBuildConfiguration": "automatic"
-}

package/bin/mcp-svc.js

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-/**
- * MCP (Model Context Protocol) Streamable HTTP 服务启动脚本
- * 用于部署到服务器，通过 HTTP 与客户端通信
- * 
- * 使用方法:
- *   node bin/mcp-svc.js
- *   或
- *   MCP_PORT=3000 node bin/mcp-svc.js
- */
-
-require('../src/mcp/index-svc.js');
-

package/src/mcp/MCP/345/234/272/346/231/257/346/250/241/346/213/237.md

@@ -1,8 +0,0 @@
-## 审批
-* 
-* 登录公司系统——》打开小云——〉点击语音输入
-* 1：帮我查看今天需要我审批的记录
-* 2：帮我预算类型的审批记录全部审批通过
-* 3：R017的报备记录文档位置不对，审批拒绝，添加交互确认
-* 4：帮我查看001预算的拆分情况
-