cloudcc-cli 2.2.6 → 2.2.8

package/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst

@@ -2,17 +2,19 @@ com/cloudcc/core/CCObject.class
 com/cloudcc/core/TriggerTimeEnum.class
 com/cloudcc/core/UserInfo.class
 com/cloudcc/core/SendEmail.class
+com/cloudcc/core/BusiException.class
 com/cloudcc/core/PeakInterf.class
 com/cloudcc/core/TimeUtil.class
 com/cloudcc/core/CCTriggerHandler.class
 com/cloudcc/core/Tool.class
 com/cloudcc/core/TriggerInvoker.class
 com/cloudcc/core/CCSchedule.class
+com/cloudcc/core/BaseException.class
 com/cloudcc/core/OperatationEnum.class
 com/cloudcc/core/TriggerMethod.class
 com/cloudcc/core/ServiceResult.class
+com/cloudcc/core/StringUtils.class
 com/cloudcc/core/DevLogger.class
 com/cloudcc/core/CCService.class
 com/cloudcc/core/CCTrigger.class
-com/cloudcc/core/CCTriggerDemo.class
 com/cloudcc/core/Tool$1.class

package/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst

@@ -2,18 +2,18 @@
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/TriggerInvoker.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/UserInfo.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/Tool.java
-/Users/xuhm/Documents/cloudcc-cli/classes/TestDtt/TestDttTest.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/CCService.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/CCSchedule.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/SendEmail.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/OperatationEnum.java
+/Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/BaseException.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/CCTriggerHandler.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/TriggerMethod.java
-/Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/CCTriggerDemo.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/TriggerTimeEnum.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/CCTrigger.java
+/Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/StringUtils.java
+/Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/BusiException.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/DevLogger.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/PeakInterf.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/TimeUtil.java
 /Users/xuhm/Documents/cloudcc-cli/java/com/cloudcc/core/CCObject.java
-/Users/xuhm/Documents/cloudcc-cli/classes/TestDtt/TestDtt.java

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"])
+    );
+  });
+});

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);
+  });
+});