cloudcc-cli 2.2.5 → 2.2.7

package/src/mcp/tools/Menu Creator/handler.js

@@ -0,0 +1,86 @@
+/**
+ * Menu Creator Handler
+ * 提供创建菜单（标签页）的 MCP 工具实现
+ * 支持类型：object（自定义对象）、page（自定义页面）、script（自定义脚本）、site（站点）
+ */
+
+const path = require('path');
+const { runCcCommand, buildRunDetail } = require('../../cliRunner');
+
+/**
+ * 创建菜单
+ * @param {{
+ *   menuType: 'object' | 'page' | 'script' | 'site',
+ *   resourceId: string,
+ *   tabName: string,
+ *   projectPath?: string
+ * }} params
+ */
+async function createMenuTool(params = {}) {
+    try {
+        const { menuType, resourceId, tabName, projectPath } = params;
+
+        // 验证必需参数
+        if (!menuType || !resourceId || !tabName) {
+            return {
+                content: [{
+                    type: 'text',
+                    text: '✗ 参数缺失: menuType (菜单类型)、resourceId (资源ID) 和 tabName (标签名称) 必须提供\n\n支持的菜单类型:\n- object: 自定义对象菜单\n- page: 自定义页面菜单\n- script: 自定义脚本菜单\n- site: 站点菜单'
+                }]
+            };
+        }
+
+        // 验证菜单类型
+        const validTypes = ['object', 'page', 'script', 'site'];
+        if (!validTypes.includes(menuType)) {
+            return {
+                content: [{
+                    type: 'text',
+                    text: `✗ 无效的菜单类型: ${menuType}\n\n支持的菜单类型:\n- object: 自定义对象菜单\n- page: 自定义页面菜单\n- script: 自定义脚本菜单\n- site: 站点菜单`
+                }]
+            };
+        }
+
+        const resolvedPath = path.resolve(projectPath || '.');
+
+        const args = [
+            'create',
+            'menu',
+            menuType,
+            resolvedPath,
+            resourceId,
+            tabName
+        ];
+
+        const runResult = runCcCommand(args, { cwd: resolvedPath });
+        const typeNameMap = { object: '对象', page: '页面', script: '脚本', site: '站点' };
+        const resourceTypeName = typeNameMap[menuType] || '资源';
+
+        if (runResult.success) {
+            return {
+                content: [{
+                    type: 'text',
+                    text: `✓ 自定义${resourceTypeName}菜单创建成功!\n\n菜单类型: ${menuType}\n资源ID: ${resourceId}\n标签名称: ${tabName}\n项目目录: ${resolvedPath}\n\n菜单已成功创建并配置到 CloudCC 系统中。`
+                }]
+            };
+        } else {
+            return {
+                content: [{
+                    type: 'text',
+                    text: `⚠ ${resourceTypeName}菜单创建遇到问题\n\n${buildRunDetail(runResult) || 'cc 命令执行失败'}\n\n请检查:\n1. 资源ID是否正确\n2. 标签名称是否符合规范\n3. CloudCC服务器连接是否正常\n4. 项目配置是否正确\n5. 是否有足够的权限创建菜单`
+                }]
+            };
+        }
+    } catch (error) {
+        return {
+            content: [{
+                type: 'text',
+                text: `✗ 菜单创建失败: ${error.message}\n\n错误详情:\n${error.stack || '无详细信息'}\n\n请检查:\n1. 资源ID是否正确\n2. 项目路径是否正确\n3. CloudCC服务器连接是否正常\n4. 项目配置文件是否存在\n5. 菜单类型是否支持`
+            }]
+        };
+    }
+}
+
+module.exports = {
+    createMenuTool
+};

package/src/mcp/tools/Object Creator/handler.js

@@ -4,6 +4,7 @@
  */
 
 const path = require('path');
+const { runCcCommand } = require('../../cliRunner');
 
 /**
  * 创建自定义对象
@@ -15,16 +16,23 @@ async function createCustomObject(params = {}) {
         return { content: [{ type: 'text', text: '✗ 参数缺失: label (对象标签) 必须提供' }] };
     }
 
-    const targetPath = projectPath || '.';
-    const resolvedPath = path.resolve(targetPath);
-    // 如果 label 包含空格或特殊字符，加双引号保护
-    const safeLabel = /\s/.test(label) ? `"${label}"` : label;
-    const command = `npx cc create object  ${targetPath} ${safeLabel}`;
+    const resolvedPath = path.resolve(projectPath || '.');
+    const runResult = runCcCommand(['create', 'object', resolvedPath, label], { cwd: resolvedPath });
+
+    if (!runResult.success) {
+        const detail = [runResult.error, runResult.stderr, runResult.stdout].filter(Boolean).join('\n');
+        return {
+            content: [{
+                type: 'text',
+                text: `✗ 自定义对象创建失败: ${detail || 'cc 命令执行失败'}`
+            }]
+        };
+    }
 
     return {
         content: [{
             type: 'text',
-            text: `✓ 自定义对象创建命令已生成!\n\n对象标签: ${label}\n项目目录(解析后): ${resolvedPath}\n\n请运行以下命令以创建对象:\n\n${command}\n\n创建过程:\n1. 生成对象的 schema 文件\n2. 配置对象权限\n3. 部署到 CloudCC 系统`
+            text: `✓ 自定义对象创建成功!\n\n调用命令: cc create object ${resolvedPath} ${label}\n项目目录: ${resolvedPath}\n对象标签: ${label}\n\n创建过程:\n1. 生成对象的 schema 文件\n2. 配置对象权限\n3. 部署到 CloudCC 系统`
         }]
     };
 }

package/src/mcp/tools/Object Fields Creator/handler.js

@@ -4,7 +4,7 @@
  */
 
 const path = require('path');
-const fieldsCreate = require('../../../fields/create');
+const { runCcCommand, buildRunDetail } = require('../../cliRunner');
 
 /**
  * 创建对象字段
@@ -19,22 +19,21 @@ const fieldsCreate = require('../../../fields/create');
  */
 async function createObjectField(params = {}) {
     try {
-        let result = null;
-        const resolvedPath = path.resolve(params.projectPath);
-        let argv = null;
+        const resolvedPath = path.resolve(params.projectPath || '.');
+        let args = ['create', 'fields', resolvedPath];
         if ("Y" == params.fieldType || "MR" == params.fieldType || "M" == params.fieldType) {
             const { objid, fieldType, nameLabel, lookupObj } = params;
-            argv = [null, null, resolvedPath, fieldType, objid, nameLabel, lookupObj];
+            args.push(fieldType, objid, nameLabel, lookupObj);
         } else if ("L" == params.fieldType || "Q" == params.fieldType) {
             const { objid, fieldType, nameLabel, ptext } = params;
-            argv = [null, null, resolvedPath, fieldType, objid, nameLabel, ptext];
+            args.push(fieldType, objid, nameLabel, ptext);
         } else {
             const { objid, fieldType, nameLabel } = params;
-            argv = [null, null, resolvedPath, fieldType, objid, nameLabel];
+            args.push(fieldType, objid, nameLabel);
         }
-        result = await fieldsCreate(argv);
+        const runResult = runCcCommand(args, { cwd: resolvedPath });
 
-        if (result) {
+        if (runResult.success) {
             return {
                 content: [{
                     type: 'text',
@@ -45,7 +44,7 @@ async function createObjectField(params = {}) {
             return {
                 content: [{
                     type: 'text',
-                    text: `⚠ 字段创建遇到问题\n\n请检查:\n1. 对象ID是否正确\n2. 字段名称是否符合规范\n3. CloudCC服务器连接是否正常\n4. 项目配置是否正确`
+                    text: `⚠ 字段创建遇到问题\n\n${buildRunDetail(runResult) || 'cc 命令执行失败'}\n\n请检查:\n1. 对象ID是否正确\n2. 字段名称是否符合规范\n3. CloudCC服务器连接是否正常\n4. 项目配置是否正确`
                 }]
             };
         }

package/src/mcp/tools/Object Fields Retriever/handler.js

@@ -4,7 +4,7 @@
  */
 
 const path = require('path');
-const fieldsGet = require('../../../fields/get');
+const { runCcJsonCommand } = require('../../cliRunner');
 
 /**
  * 获取对象字段
@@ -21,8 +21,11 @@ async function getFields(params = {}) {
             return { content: [{ type: 'text', text: '✗ 缺少参数: 需要 objprefix' }] };
         }
 
-        const argv = [null, null, resolvedPath, objprefix];
-        const res = await fieldsGet(argv, true);
+        const run = runCcJsonCommand(['get', 'fields', resolvedPath, objprefix], { cwd: resolvedPath });
+        if (!run.success) {
+            return { content: [{ type: 'text', text: `✗ 查询失败: ${run.detail || 'cc 命令执行失败'}` }] };
+        }
+        const res = run.data;
 
         if (!res || (Array.isArray(res) && res.length === 0)) {
             return { content: [{ type: 'text', text: '未找到任何字段' }] };

package/src/mcp/tools/Object List Retriever/handler.js

@@ -4,7 +4,7 @@
  */
 
 const path = require('path');
-const objectGet = require('../../../object/get');
+const { runCcJsonCommand } = require('../../cliRunner');
 /**
  * 列出对象
  * @param {{ type?: 'standard'|'custom'|'both', projectPath?: string }} params
@@ -13,12 +13,15 @@ async function listObjects(params = {}) {
     try {
         const { type = 'both', projectPath = process.cwd() } = params;
         const resolvedPath = path.resolve(projectPath);
-
-        // Map our 'both' to no explicit type to get the combined list
-        const getType = type === 'both' ? undefined : type;
-
-        const argv = [null, null, resolvedPath, getType];
-        const objList = await objectGet(argv, true);
+        const args = ['get', 'object', resolvedPath];
+        if (type !== 'both') {
+            args.push(type);
+        }
+        const run = runCcJsonCommand(args, { cwd: resolvedPath });
+        if (!run.success) {
+            return { content: [{ type: 'text', text: `✗ 查询失败: ${run.detail || 'cc 命令执行失败'}` }] };
+        }
+        const objList = run.data || [];
         if (!objList || objList.length === 0) {
             return { content: [{ type: 'text', text: '未找到任何对象' }] };
         }

package/src/mcp/tools/Scheduled Class Creator/handler.js

@@ -4,29 +4,25 @@
  */
 
 const path = require('path');
-const createScheduleModule = require('../../../timer/create');
+const { runCcCommand, buildRunDetail } = require('../../cliRunner');
 
 /**
  * 创建定时类
  */
 async function createSchedule({ scheduleName, projectPath = process.cwd() }) {
     try {
-        // 临时改变工作目录以兼容原有模块
-        const originalCwd = process.cwd();
-        process.chdir(projectPath);
-
-        try {
-            await createScheduleModule(scheduleName);
-            const schedulePath = path.resolve(projectPath, `schedule/${scheduleName}`);
-            return {
-                content: [{
-                    type: 'text',
-                    text: `✓ 创建成功！\n\n定时类路径: ${schedulePath}\n生成的文件:\n  - ${scheduleName}.java (主类文件，继承 CCSchedule)\n  - config.json (配置文件)\n\n定时类与自定义类的区别：\n  - 定时类继承 CCSchedule，用于定时任务执行\n  - 代码写在构造函数中，系统会按设定的时间调度执行`
-                }]
-            };
-        } finally {
-            process.chdir(originalCwd);
+        const resolvedPath = path.resolve(projectPath);
+        const run = runCcCommand(['create', 'schedule', scheduleName], { cwd: resolvedPath });
+        if (!run.success) {
+            return { content: [{ type: 'text', text: `✗ 创建失败: ${buildRunDetail(run) || 'cc 命令执行失败'}` }] };
         }
+        const schedulePath = path.resolve(projectPath, `schedule/${scheduleName}`);
+        return {
+            content: [{
+                type: 'text',
+                text: `✓ 创建成功！\n\n定时类路径: ${schedulePath}\n生成的文件:\n  - ${scheduleName}.java (主类文件，继承 CCSchedule)\n  - config.json (配置文件)\n\n定时类与自定义类的区别：\n  - 定时类继承 CCSchedule，用于定时任务执行\n  - 代码写在构造函数中，系统会按设定的时间调度执行`
+            }]
+        };
     } catch (error) {
         return { content: [{ type: 'text', text: `✗ 创建失败: ${error.message}` }] };
     }

package/src/mcp/tools/Scheduled Class Detail Retriever/handler.js

@@ -3,7 +3,8 @@
  * 获取定时类的详细信息
  */
 
-const detailModule = require('../../../timer/detail');
+const path = require('path');
+const { runCcJsonCommand } = require('../../cliRunner');
 
 /**
  * 获取定时类详细信息
@@ -14,15 +15,12 @@ const detailModule = require('../../../timer/detail');
  */
 async function getScheduleDetail({ scheduleName, scheduleId, projectPath = process.cwd() }) {
     try {
-        const originalCwd = process.cwd();
-        process.chdir(projectPath);
-
-        try {
-            const detail = await detailModule(scheduleName, scheduleId);
-            return { content: [{ type: 'text', text: JSON.stringify(detail, null, 2) }] };
-        } finally {
-            process.chdir(originalCwd);
+        const resolvedPath = path.resolve(projectPath);
+        const run = runCcJsonCommand(['detail', 'schedule', scheduleName || '', scheduleId || ''], { cwd: resolvedPath });
+        if (!run.success) {
+            return { content: [{ type: 'text', text: `✗ 获取失败: ${run.detail || 'cc 命令执行失败'}` }] };
         }
+        return { content: [{ type: 'text', text: JSON.stringify(run.data, null, 2) }] };
     } catch (error) {
         return { content: [{ type: 'text', text: `✗ 获取失败: ${error.message}` }] };
     }

package/src/mcp/tools/Scheduled Class List Retriever/handler.js

@@ -3,38 +3,36 @@
  * 查询定时类列表
  */
 
-const getScheduleModule = require('../../../timer/get');
+const path = require('path');
+const { runCcJsonCommand } = require('../../cliRunner');
 
 /**
  * 获取定时类列表
  */
 async function listSchedules({ projectPath = process.cwd() }) {
     try {
-        const originalCwd = process.cwd();
-        process.chdir(projectPath);
-
-        try {
-            const result = await getScheduleModule('', projectPath, true);
-
-            if (!result || result.length === 0) {
-                return {
-                    content: [{
-                        type: 'text',
-                        text: '未找到任何定时器类\n\n提示：使用 create_schedule 创建新定时器类'
-                    }]
-                };
-            }
+        const resolvedPath = path.resolve(projectPath);
+        const run = runCcJsonCommand(['get', 'schedule'], { cwd: resolvedPath });
+        if (!run.success) {
+            return { content: [{ type: 'text', text: `获取定时类列表失败: ${run.detail || 'cc 命令执行失败'}` }] };
+        }
+        const result = run.data || [];
+        if (!result.length) {
             return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(result, null, 2)
-                    }
-                ]
+                content: [{
+                    type: 'text',
+                    text: '未找到任何定时器类\n\n提示：使用 create_schedule 创建新定时器类'
+                }]
             };
-        } finally {
-            process.chdir(originalCwd);
         }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2)
+                }
+            ]
+        };
     } catch (error) {
         return {
             content: [

package/src/mcp/tools/Scheduled Class Publisher/handler.js

@@ -3,22 +3,20 @@
  * 发布定时类到服务器
  */
 
-const publishScheduleModule = require('../../../timer/publish');
+const path = require('path');
+const { runCcCommand, buildRunDetail } = require('../../cliRunner');
 
 /**
  * 发布定时类到服务器
  */
 async function publishSchedule({ scheduleName, projectPath = process.cwd() }) {
     try {
-        const originalCwd = process.cwd();
-        process.chdir(projectPath);
-
-        try {
-            await publishScheduleModule(scheduleName);
-            return { content: [{ type: 'text', text: `✓ 发布成功！定时类 ${scheduleName} 已发布到服务器` }] };
-        } finally {
-            process.chdir(originalCwd);
+        const resolvedPath = path.resolve(projectPath);
+        const run = runCcCommand(['publish', 'schedule', scheduleName], { cwd: resolvedPath });
+        if (!run.success) {
+            return { content: [{ type: 'text', text: `✗ 发布失败: ${buildRunDetail(run) || 'cc 命令执行失败'}` }] };
         }
+        return { content: [{ type: 'text', text: `✓ 发布成功！定时类 ${scheduleName} 已发布到服务器` }] };
     } catch (error) {
         return { content: [{ type: 'text', text: `✗ 发布失败: ${error.message}` }] };
     }

package/src/mcp/tools/Scheduled Class Puller/handler.js

@@ -3,84 +3,20 @@
  * 从服务器拉取定时类
  */
 
-const fs = require('fs');
 const path = require('path');
-const getScheduleModule = require('../../../timer/get');
-const pullScheduleModule = require('../../../timer/pull');
-const pullListModule = require('../../../timer/pullList');
+const { runCcCommand, buildRunDetail } = require('../../cliRunner');
 
 /**
  * 从服务器拉取定时类
  */
 async function pullSchedule({ scheduleName, projectPath = process.cwd() }) {
     try {
-        const schedulePath = path.join(projectPath, `schedule/${scheduleName}`);
-        const configPath = path.join(schedulePath, 'config.json');
-
-        // 检查本地是否存在该定时类
-        if (!fs.existsSync(configPath)) {
-            // 本地不存在，查询服务器
-            try {
-                const queryString = encodeURI(JSON.stringify({
-                    shownum: "2000",
-                    showpage: "1",
-                    fid: "",
-                    sname: scheduleName,
-                    rptcond: '',
-                    rptorder: ''
-                }));
-                const scheduleList = await getScheduleModule(queryString, projectPath);
-
-                if (!scheduleList || scheduleList.length === 0) {
-                    return {
-                        content: [{
-                            type: 'text',
-                            text: `✗ 拉取失败: 服务器上不存在定时类 ${scheduleName}`
-                        }]
-                    };
-                }
-
-                // 找到匹配的定时类
-                const targetSchedule = scheduleList.find(item => item.name === scheduleName || item.apiname === scheduleName);
-                if (!targetSchedule) {
-                    return {
-                        content: [{
-                            type: 'text',
-                            text: `✗ 拉取失败: 服务器上未找到定时类 ${scheduleName}`
-                        }]
-                    };
-                }
-
-                // 使用 ID 从服务器拉取并在本地创建
-                const originalCwd = process.cwd();
-                process.chdir(projectPath);
-
-                try {
-                    await pullListModule(targetSchedule.id, projectPath);
-                    return {
-                        content: [{
-                            type: 'text',
-                            text: `✓ 拉取成功！已从服务器拉取定时类 ${scheduleName} 并在本地创建\n\n本地路径: schedule/${scheduleName}/`
-                        }]
-                    };
-                } finally {
-                    process.chdir(originalCwd);
-                }
-            } catch (error) {
-                return { content: [{ type: 'text', text: `✗ 拉取失败: ${error.message}` }] };
-            }
-        }
-
-        // 本地存在，直接更新
-        const originalCwd = process.cwd();
-        process.chdir(projectPath);
-
-        try {
-            await pullScheduleModule(scheduleName);
-            return { content: [{ type: 'text', text: `✓ 拉取成功！本地文件已更新: schedule/${scheduleName}/${scheduleName}.java` }] };
-        } finally {
-            process.chdir(originalCwd);
+        const resolvedPath = path.resolve(projectPath);
+        const run = runCcCommand(['pull', 'schedule', scheduleName], { cwd: resolvedPath });
+        if (!run.success) {
+            return { content: [{ type: 'text', text: `✗ 拉取失败: ${buildRunDetail(run) || 'cc 命令执行失败'}` }] };
         }
+        return { content: [{ type: 'text', text: `✓ 拉取成功！本地文件已更新: schedule/${scheduleName}/${scheduleName}.java` }] };
     } catch (error) {
         return { content: [{ type: 'text', text: `✗ 拉取失败: ${error.message}` }] };
     }

package/src/mcp/tools/Trigger Creator/handler.js

@@ -4,7 +4,7 @@
  */
 
 const path = require('path');
-const createTriggerModule = require('../../../triggers/create');
+const { runCcCommand, buildRunDetail } = require('../../cliRunner');
 
 /**
  * 创建触发器
@@ -17,32 +17,24 @@ const createTriggerModule = require('../../../triggers/create');
  */
 async function createTrigger({ triggerName, objectName, targetObjectId, triggerTime, projectPath = process.cwd() }) {
     try {
-        // 构造传递给底层模块的参数
         const body = {
             name: triggerName,
             schemetableName: objectName,
             targetObjectId: targetObjectId,
             triggerTime: triggerTime
         };
-        
-        const argvs = ['', '', encodeURI(JSON.stringify(body))];
-        
-        // 临时改变工作目录以兼容原有模块
-        const originalCwd = process.cwd();
-        process.chdir(projectPath);
-
-        try {
-            await createTriggerModule(argvs);
-            const triggerPath = path.resolve(projectPath, `triggers/${objectName.toLowerCase()}/${triggerName}`);
-            return {
-                content: [{
-                    type: 'text',
-                    text: `✓ 创建成功！\n\n触发器路径: ${triggerPath}\n生成的文件:\n  - ${triggerName}.java (主类文件，继承 CCTrigger)\n  - config.json (配置文件)\n\n触发器说明：\n  - 触发器继承 CCTrigger，用于在对象操作时执行特定逻辑\n  - 对象：${objectName}\n  - 触发时间：${triggerTime}\n  - 代码写在构造函数中，系统会在指定时机自动执行`
-                }]
-            };
-        } finally {
-            process.chdir(originalCwd);
+        const resolvedPath = path.resolve(projectPath);
+        const run = runCcCommand(['create', 'triggers', encodeURI(JSON.stringify(body))], { cwd: resolvedPath });
+        if (!run.success) {
+            return { content: [{ type: 'text', text: `✗ 创建失败: ${buildRunDetail(run) || 'cc 命令执行失败'}` }] };
         }
+        const triggerPath = path.resolve(projectPath, `triggers/${objectName.toLowerCase()}/${triggerName}`);
+        return {
+            content: [{
+                type: 'text',
+                text: `✓ 创建成功！\n\n触发器路径: ${triggerPath}\n生成的文件:\n  - ${triggerName}.java (主类文件，继承 CCTrigger)\n  - config.json (配置文件)\n\n触发器说明：\n  - 触发器继承 CCTrigger，用于在对象操作时执行特定逻辑\n  - 对象：${objectName}\n  - 触发时间：${triggerTime}\n  - 代码写在构造函数中，系统会在指定时机自动执行`
+            }]
+        };
     } catch (error) {
         return { content: [{ type: 'text', text: `✗ 创建失败: ${error.message}` }] };
     }

package/src/mcp/tools/Trigger Detail Retriever/handler.js

@@ -3,7 +3,8 @@
  * 获取触发器的详细信息
  */
 
-const detailModule = require('../../../triggers/detail');
+const path = require('path');
+const { runCcJsonCommand } = require('../../cliRunner');
 
 /**
  * 获取触发器详细信息
@@ -14,15 +15,12 @@ const detailModule = require('../../../triggers/detail');
  */
 async function getTriggerDetail({ triggerPath, triggerId, projectPath = process.cwd() }) {
     try {
-        const originalCwd = process.cwd();
-        process.chdir(projectPath);
-
-        try {
-            const detail = await detailModule(triggerPath, triggerId);
-            return { content: [{ type: 'text', text: JSON.stringify(detail, null, 2) }] };
-        } finally {
-            process.chdir(originalCwd);
+        const resolvedPath = path.resolve(projectPath);
+        const run = runCcJsonCommand(['detail', 'triggers', triggerPath || '', triggerId || ''], { cwd: resolvedPath });
+        if (!run.success) {
+            return { content: [{ type: 'text', text: `✗ 获取失败: ${run.detail || 'cc 命令执行失败'}` }] };
         }
+        return { content: [{ type: 'text', text: JSON.stringify(run.data, null, 2) }] };
     } catch (error) {
         return { content: [{ type: 'text', text: `✗ 获取失败: ${error.message}` }] };
     }

package/src/mcp/tools/Trigger Editor Guide/handler.js

@@ -3,7 +3,7 @@
  * 提供触发器编辑指南，使用与自定义类和定时类相同的知识库
  */
 
-const classEditorGuideHandler = require('../Class Editor Guide/handler.js');
+const { runCcCommand, buildRunDetail } = require('../../cliRunner');
 
 /**
  * 获取触发器编辑指南
@@ -13,41 +13,16 @@ const classEditorGuideHandler = require('../Class Editor Guide/handler.js');
  */
 async function editTrigger({ topic = 'overview' }) {
     try {
-        // 触发器使用与自定义类和定时类相同的编辑指南
-        // 只是继承的基类不同（CCTrigger vs CCClass vs CCSchedule）
-        const result = await classEditorGuideHandler.editClass({ topic });
-        
-        // 在结果前添加触发器特定说明
-        if (result.content && result.content[0]) {
-            const triggerNote = `
-📌 触发器特别说明：
-------------------
-触发器继承 CCTrigger 类，用于在对象操作时自动执行特定逻辑。
-
-触发器与自定义类/定时类的主要区别：
-1. 继承基类：extends CCTrigger
-2. 触发时机：通过 triggerTime 配置（beforeInsert, beforeUpdate, beforeUpsert, beforeDelete, afterInsert, afterUpdate, afterUpsert, afterDelete, afterInsertCommit, afterUpdateCommit, afterUpsertCommit, afterDeleteCommit, approval, beforeBatch, afterBatch, commitBatch）
-3. 关联对象：触发器与特定对象绑定（targetObjectId）
-4. 执行时机：在对象操作时自动触发，无需手动调用
-5. 常见用途：数据验证、字段自动填充、关联数据更新、业务规则检查等
-
-触发器中可访问的特殊变量：
-- newList：新记录列表（insert/update操作）
-- oldList：旧记录列表（update/delete操作）
-- trigger.isInsert：是否为插入操作
-- trigger.isUpdate：是否为更新操作
-- trigger.isDelete：是否为删除操作
-- trigger.isBefore：是否为before触发器
-- trigger.isAfter：是否为after触发器
-
-以下是触发器开发的通用API文档（与自定义类、定时类共享）：
-==========================================
-
-`;
-            result.content[0].text = triggerNote + result.content[0].text;
+        const run = runCcCommand(['doc', 'triggers', topic]);
+        if (!run.success) {
+            return { content: [{ type: 'text', text: `✗ 获取触发器编辑指南失败: ${buildRunDetail(run) || 'cc 命令执行失败'}` }] };
         }
-        
-        return result;
+        return {
+            content: [{
+                type: 'text',
+                text: run.stdout || ''
+            }]
+        };
     } catch (error) {
         return { content: [{ type: 'text', text: `✗ 获取触发器编辑指南失败: ${error.message}` }] };
     }