@cloudbase/cloudbase-mcp 2.9.0 → 2.11.0

package/dist/index.js

@@ -562,7 +562,7 @@ ${envIdSection}
 ## 环境信息
 - 操作系统: ${os_1.default.type()} ${os_1.default.release()}
 - Node.js版本: ${process.version}
-- MCP 版本：${process.env.npm_package_version || "2.9.0" || 0}
+- MCP 版本：${process.env.npm_package_version || "2.11.0" || 0}
 - 系统架构: ${os_1.default.arch()}
 - 时间: ${new Date().toISOString()}
 - 请求ID: ${requestId}
@@ -971,11 +971,43 @@ exports.resetInteractiveServer = resetInteractiveServer;
 exports.getInteractiveServerSafe = getInteractiveServerSafe;
 const express_1 = __importDefault(__webpack_require__(2674));
 const http_1 = __importDefault(__webpack_require__(3782));
+const child_process_1 = __webpack_require__(5814);
 const open_1 = __importDefault(__webpack_require__(1622));
 const ws_1 = __webpack_require__(6220);
 const index_js_1 = __webpack_require__(9529);
 const logger_js_1 = __webpack_require__(3039);
-// 动态导入 open 模块，兼容 ESM/CJS 环境
+function isVSCodeEnvironment() {
+    return Boolean(process.env.VSCODE_IPC_HOOK_CLI ||
+        process.env.VSCODE_PID ||
+        process.env.TERM_PROGRAM === "vscode");
+}
+function parseBrowserCommand(browser) {
+    const parts = browser.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+    return parts.map((item) => item.replace(/^"(.*)"$/, "$1"));
+}
+async function openUrlByBrowserEnv(url) {
+    const browser = process.env.BROWSER?.trim();
+    if (!browser) {
+        return false;
+    }
+    const [command, ...args] = parseBrowserCommand(browser);
+    if (!command) {
+        return false;
+    }
+    const finalArgs = args.map((arg) => (arg === "%s" ? url : arg));
+    if (!args.includes("%s")) {
+        finalArgs.push(url);
+    }
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)(command, finalArgs, (execError) => {
+            resolve(!execError);
+        });
+    });
+}
+function shouldUseBrowserEnvFallback() {
+    return process.platform === "linux" && isVSCodeEnvironment();
+}
+// Dynamic open behavior with IDE awareness and VSCode/Linux fallback
 async function openUrl(url, options, mcpServer) {
     // mcpServer 是 ExtendedMcpServer 实例，它有 server 和 ide 属性
     // server 属性是 MCP server 的内部 server 实例，有 sendLoggingMessage 方法
@@ -1007,13 +1039,28 @@ async function openUrl(url, options, mcpServer) {
             return;
         }
     }
-    // 默认行为：直接打开网页
+    // 默认行为：直接打开网页（带 VSCode/Linux 降级逻辑）
     (0, logger_js_1.debug)(`[openUrl] Opening URL in browser: ${url}`);
     try {
-        return await (0, open_1.default)(url, options);
+        const openOptions = options ? { url: true, ...options } : { url: true };
+        const child = await (0, open_1.default)(url, openOptions);
+        if (child?.once) {
+            child.once("error", async () => {
+                if (shouldUseBrowserEnvFallback()) {
+                    (0, logger_js_1.debug)("[openUrl] open() failed, trying BROWSER fallback");
+                    await openUrlByBrowserEnv(url);
+                }
+            });
+        }
+        return;
     }
     catch (err) {
         (0, logger_js_1.error)(`Failed to open ${url} ${options} ${err instanceof Error ? err.message : err} `, err instanceof Error ? err : new Error(String(err)));
+        if (shouldUseBrowserEnvFallback()) {
+            (0, logger_js_1.debug)("[openUrl] open() threw, trying BROWSER fallback");
+            await openUrlByBrowserEnv(url);
+            return;
+        }
         (0, logger_js_1.warn)(`Please manually open: ${url}`);
     }
 }
@@ -5267,9 +5314,13 @@ checkIndex: 检查索引是否存在`),
         title: "修改 NoSQL 数据库结构",
         description: "修改 NoSQL 数据库结构",
         inputSchema: {
-            action: zod_1.z.enum(["createCollection", "updateCollection"])
-                .describe(`createCollection: 创建集合
-updateCollection: 更新集合`),
+            action: zod_1.z.enum([
+                "createCollection",
+                "updateCollection",
+                "deleteCollection",
+            ]).describe(`createCollection: 创建集合
+updateCollection: 更新集合
+deleteCollection: 删除集合`),
             collectionName: zod_1.z.string().describe("集合名称"),
             updateOptions: zod_1.z
                 .object({
@@ -5296,68 +5347,72 @@ updateCollection: 更新集合`),
         },
         annotations: {
             readOnlyHint: false,
-            destructiveHint: false,
+            destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
             category: CATEGORY,
         },
     }, async ({ action, collectionName, updateOptions }) => {
-        try {
-            const cloudbase = await getManager();
-            if (action === "createCollection") {
-                const result = await cloudbase.database.createCollection(collectionName);
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                requestId: result.RequestId,
-                                action,
-                                message: "云开发数据库集合创建成功",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (action === "updateCollection") {
-                if (!updateOptions) {
-                    throw new Error("更新集合时必须提供 options");
-                }
-                const result = await cloudbase.database.updateCollection(collectionName, updateOptions);
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                requestId: result.RequestId,
-                                action,
-                                message: "云开发数据库集合更新成功",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            throw new Error(`不支持的操作类型: ${action}`);
+        const cloudbase = await getManager();
+        if (action === "createCollection") {
+            const result = await cloudbase.database.createCollection(collectionName);
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            requestId: result.RequestId,
+                            action,
+                            message: "云开发数据库集合创建成功",
+                        }, null, 2),
+                    },
+                ],
+            };
         }
-        catch (error) {
+        if (action === "updateCollection") {
+            if (!updateOptions) {
+                throw new Error("更新集合时必须提供 options");
+            }
+            const result = await cloudbase.database.updateCollection(collectionName, updateOptions);
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            success: false,
+                            success: true,
+                            requestId: result.RequestId,
                             action,
-                            error: error.message,
-                            message: "集合创建/更新操作失败",
+                            message: "云开发数据库集合更新成功",
                         }, null, 2),
                     },
                 ],
             };
         }
+        if (action === "deleteCollection") {
+            const result = await cloudbase.database.deleteCollection(collectionName);
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+            const body = {
+                success: true,
+                requestId: result.RequestId,
+                action,
+                message: result.Exists === false ? "集合不存在" : "云开发数据库集合删除成功",
+            };
+            if (result.Exists === false) {
+                body.exists = false;
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(body, null, 2),
+                    },
+                ],
+            };
+        }
+        throw new Error(`不支持的操作类型: ${action}`);
     });
     // readNoSqlDatabaseContent
     server.registerTool?.("readNoSqlDatabaseContent", {
@@ -5374,9 +5429,17 @@ updateCollection: 更新集合`),
                 .optional()
                 .describe("返回字段投影(对象或字符串,推荐对象)"),
             sort: zod_1.z
-                .union([zod_1.z.object({}).passthrough(), zod_1.z.string()])
+                .union([
+                zod_1.z.array(zod_1.z
+                    .object({
+                    key: zod_1.z.string().describe("sort 字段名"),
+                    direction: zod_1.z.number().describe("排序方向,1:升序,-1:降序"),
+                })
+                    .passthrough()),
+                zod_1.z.string(),
+            ])
                 .optional()
-                .describe("排序条件(对象或字符串,推荐对象)"),
+                .describe("排序条件，使用对象或字符串。"),
             limit: zod_1.z.number().optional().describe("返回数量限制"),
             offset: zod_1.z.number().optional().describe("跳过的记录数"),
         },
@@ -5386,63 +5449,45 @@ updateCollection: 更新集合`),
             category: CATEGORY,
         },
     }, async ({ collectionName, query, projection, sort, limit, offset }) => {
-        try {
-            const cloudbase = await getManager();
-            const instanceId = await getDatabaseInstanceId(getManager);
-            // 兼容对象和字符串
-            const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
-            const result = await cloudbase.commonService("tcb", "2018-06-08").call({
-                Action: "QueryRecords",
-                Param: {
-                    TableName: collectionName,
-                    MgoQuery: toJSONString(query),
-                    MgoProjection: toJSONString(projection),
-                    MgoSort: toJSONString(sort),
-                    MgoLimit: limit ?? 100, // 默认返回100条,避免底层SDK缺参报错
-                    MgoOffset: offset,
-                    Tag: instanceId,
+        const cloudbase = await getManager();
+        const instanceId = await getDatabaseInstanceId(getManager);
+        const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
+        const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+            Action: "QueryRecords",
+            Param: {
+                TableName: collectionName,
+                MgoQuery: toJSONString(query),
+                MgoProjection: toJSONString(projection),
+                MgoSort: toJSONString(sort),
+                MgoLimit: limit ?? 100,
+                MgoOffset: offset,
+                Tag: instanceId,
+            },
+        });
+        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        requestId: result.RequestId,
+                        data: result.Data,
+                        pager: result.Pager,
+                        message: "文档查询成功",
+                    }, null, 2),
                 },
-            });
-            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            requestId: result.RequestId,
-                            data: result.Data,
-                            pager: result.Pager,
-                            message: "文档查询成功",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message,
-                            message: "文档查询失败",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
+            ],
+        };
     });
     // writeNoSqlDatabaseContent
     server.registerTool?.("writeNoSqlDatabaseContent", {
         title: "修改 NoSQL 数据库数据记录",
         description: "修改 NoSQL 数据库数据记录",
         inputSchema: {
-            action: zod_1.z.enum(["insert", "update", "delete"])
-                .describe(`createCollection: 创建数据
-updateCollection: 更新数据
-deleteCollection: 删除数据`),
+            action: zod_1.z
+                .enum(["insert", "update", "delete"])
+                .describe(`insert: 插入数据（新增文档）\nupdate: 更新数据\ndelete: 删除数据`),
             collectionName: zod_1.z.string().describe("集合名称"),
             documents: zod_1.z
                 .array(zod_1.z.object({}).passthrough())
@@ -5541,98 +5586,70 @@ deleteCollection: 删除数据`),
     });
 }
 async function insertDocuments({ collectionName, documents, getManager, logger, }) {
-    try {
-        const cloudbase = await getManager();
-        const instanceId = await getDatabaseInstanceId(getManager);
-        // 将对象数组序列化为字符串数组
-        const docsAsStrings = documents.map((doc) => JSON.stringify(doc));
-        const result = await cloudbase.commonService("tcb", "2018-06-08").call({
-            Action: "PutItem",
-            Param: {
-                TableName: collectionName,
-                MgoDocs: docsAsStrings,
-                Tag: instanceId,
-            },
-        });
-        (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
-        return JSON.stringify({
-            success: true,
-            requestId: result.RequestId,
-            insertedIds: result.InsertedIds,
-            message: "文档插入成功",
-        }, null, 2);
-    }
-    catch (error) {
-        return JSON.stringify({
-            success: false,
-            error: error.message,
-            message: "文档插入失败",
-        }, null, 2);
-    }
+    const cloudbase = await getManager();
+    const instanceId = await getDatabaseInstanceId(getManager);
+    const docsAsStrings = documents.map((doc) => JSON.stringify(doc));
+    const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+        Action: "PutItem",
+        Param: {
+            TableName: collectionName,
+            MgoDocs: docsAsStrings,
+            Tag: instanceId,
+        },
+    });
+    (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
+    return JSON.stringify({
+        success: true,
+        requestId: result.RequestId,
+        insertedIds: result.InsertedIds,
+        message: "文档插入成功",
+    }, null, 2);
 }
 async function updateDocuments({ collectionName, query, update, isMulti, upsert, getManager, logger, }) {
-    try {
-        const cloudbase = await getManager();
-        const instanceId = await getDatabaseInstanceId(getManager);
-        const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
-        const result = await cloudbase.commonService("tcb", "2018-06-08").call({
-            Action: "UpdateItem",
-            Param: {
-                TableName: collectionName,
-                MgoQuery: toJSONString(query),
-                MgoUpdate: toJSONString(update),
-                MgoIsMulti: isMulti,
-                MgoUpsert: upsert,
-                Tag: instanceId,
-            },
-        });
-        (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
-        return JSON.stringify({
-            success: true,
-            requestId: result.RequestId,
-            modifiedCount: result.ModifiedNum,
-            matchedCount: result.MatchedNum,
-            upsertedId: result.UpsertedId,
-            message: "文档更新成功",
-        }, null, 2);
-    }
-    catch (error) {
-        return JSON.stringify({
-            success: false,
-            error: error.message,
-            message: "文档更新失败",
-        }, null, 2);
-    }
+    const cloudbase = await getManager();
+    const instanceId = await getDatabaseInstanceId(getManager);
+    const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
+    const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+        Action: "UpdateItem",
+        Param: {
+            TableName: collectionName,
+            MgoQuery: toJSONString(query),
+            MgoUpdate: toJSONString(update),
+            MgoIsMulti: isMulti,
+            MgoUpsert: upsert,
+            Tag: instanceId,
+        },
+    });
+    (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
+    return JSON.stringify({
+        success: true,
+        requestId: result.RequestId,
+        modifiedCount: result.ModifiedNum,
+        matchedCount: result.MatchedNum,
+        upsertedId: result.UpsertedId,
+        message: "文档更新成功",
+    }, null, 2);
 }
 async function deleteDocuments({ collectionName, query, isMulti, getManager, logger, }) {
-    try {
-        const cloudbase = await getManager();
-        const instanceId = await getDatabaseInstanceId(getManager);
-        const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
-        const result = await cloudbase.commonService("tcb", "2018-06-08").call({
-            Action: "DeleteItem",
-            Param: {
-                TableName: collectionName,
-                MgoQuery: toJSONString(query),
-                MgoIsMulti: isMulti,
-                Tag: instanceId,
-            },
-        });
-        (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
-        return JSON.stringify({
-            success: true,
-            requestId: result.RequestId,
-            deleted: result.Deleted,
-            message: "文档删除成功",
-        }, null, 2);
-    }
-    catch (error) {
-        return JSON.stringify({
-            success: false,
-            error: error.message,
-            message: "文档删除失败",
-        }, null, 2);
-    }
+    const cloudbase = await getManager();
+    const instanceId = await getDatabaseInstanceId(getManager);
+    const toJSONString = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
+    const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+        Action: "DeleteItem",
+        Param: {
+            TableName: collectionName,
+            MgoQuery: toJSONString(query),
+            MgoIsMulti: isMulti,
+            Tag: instanceId,
+        },
+    });
+    (0, cloudbase_manager_js_1.logCloudBaseResult)(logger, result);
+    return JSON.stringify({
+        success: true,
+        requestId: result.RequestId,
+        deleted: result.Deleted,
+        message: "文档删除成功",
+    }, null, 2);
 }
 
 
@@ -6202,289 +6219,271 @@ function registerDataModelTools(server) {
             category: "database",
         },
     }, async ({ action, name, names, }) => {
-        try {
-            const cloudbase = await getManager();
-            let currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            let result;
-            switch (action) {
-                case "get":
-                    if (!name) {
-                        throw new Error("获取数据模型需要提供模型名称");
-                    }
-                    try {
-                        result = await cloudbase.commonService("lowcode").call({
-                            Action: "DescribeBasicDataSource",
-                            Param: {
-                                EnvId: currentEnvId,
-                                Name: name,
-                            },
-                        });
-                        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                        // 只保留基础字段，过滤掉冗余信息，并简化Schema
-                        let simplifiedSchema = null;
-                        // 解析并简化Schema
-                        if (result.Data.Schema) {
-                            try {
-                                const schema = JSON.parse(result.Data.Schema);
-                                const properties = schema.properties || {};
-                                // 提取用户定义的字段（排除系统字段）
-                                const userFields = Object.keys(properties)
-                                    .filter((key) => !properties[key]["x-system"]) // 排除系统字段
-                                    .map((key) => {
-                                    const field = properties[key];
-                                    return parseFieldStructure(field, key, schema);
-                                });
-                                // 提取关联关系
-                                const relations = userFields
-                                    .filter((field) => field.linkage)
-                                    .map((field) => ({
-                                    field: field.name,
-                                    type: field.format,
-                                    title: field.title,
-                                    targetModel: field.linkage.parentDataSourceName,
-                                    foreignKey: field.linkage.parentFieldKey,
-                                    displayField: field.linkage.parentFieldTitle,
-                                }));
-                                simplifiedSchema = {
-                                    userFields,
-                                    relations,
-                                    totalFields: Object.keys(properties).length,
-                                    userFieldsCount: userFields.length,
-                                };
-                            }
-                            catch (e) {
-                                simplifiedSchema = { error: "Schema解析失败" };
-                            }
+        const cloudbase = await getManager();
+        let currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        let result;
+        switch (action) {
+            case "get":
+                if (!name) {
+                    throw new Error("获取数据模型需要提供模型名称");
+                }
+                try {
+                    result = await cloudbase.commonService("lowcode").call({
+                        Action: "DescribeBasicDataSource",
+                        Param: {
+                            EnvId: currentEnvId,
+                            Name: name,
+                        },
+                    });
+                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+                    // 只保留基础字段，过滤掉冗余信息，并简化Schema
+                    let simplifiedSchema = null;
+                    // 解析并简化Schema
+                    if (result.Data.Schema) {
+                        try {
+                            const schema = JSON.parse(result.Data.Schema);
+                            const properties = schema.properties || {};
+                            // 提取用户定义的字段（排除系统字段）
+                            const userFields = Object.keys(properties)
+                                .filter((key) => !properties[key]["x-system"]) // 排除系统字段
+                                .map((key) => {
+                                const field = properties[key];
+                                return parseFieldStructure(field, key, schema);
+                            });
+                            // 提取关联关系
+                            const relations = userFields
+                                .filter((field) => field.linkage)
+                                .map((field) => ({
+                                field: field.name,
+                                type: field.format,
+                                title: field.title,
+                                targetModel: field.linkage.parentDataSourceName,
+                                foreignKey: field.linkage.parentFieldKey,
+                                displayField: field.linkage.parentFieldTitle,
+                            }));
+                            simplifiedSchema = {
+                                userFields,
+                                relations,
+                                totalFields: Object.keys(properties).length,
+                                userFieldsCount: userFields.length,
+                            };
                         }
-                        // 尝试生成Mermaid图表
-                        let mermaidDiagram = null;
-                        if (result.Data.Schema &&
-                            jsonSchemaToMermaid &&
-                            simplifiedSchema &&
-                            !simplifiedSchema.error) {
-                            try {
-                                const mainSchema = JSON.parse(result.Data.Schema);
-                                const schemasMap = {
-                                    [name]: mainSchema,
-                                };
-                                // 获取关联模型的 schema
-                                if (simplifiedSchema.relations &&
-                                    simplifiedSchema.relations.length > 0) {
-                                    const relatedModelNames = [
-                                        ...new Set(simplifiedSchema.relations.map((rel) => rel.targetModel)),
-                                    ];
-                                    for (const relatedModelName of relatedModelNames) {
-                                        try {
-                                            const relatedResult = await cloudbase
-                                                .commonService("lowcode")
-                                                .call({
-                                                Action: "DescribeBasicDataSource",
-                                                Param: {
-                                                    EnvId: currentEnvId,
-                                                    Name: relatedModelName,
-                                                },
-                                            });
-                                            if (relatedResult.Data && relatedResult.Data.Schema) {
-                                                schemasMap[relatedModelName] = JSON.parse(relatedResult.Data.Schema);
-                                            }
-                                        }
-                                        catch (e) {
-                                            console.warn(`获取关联模型 ${relatedModelName} 的 schema 失败:`, e);
+                        catch (e) {
+                            simplifiedSchema = { error: "Schema解析失败" };
+                        }
+                    }
+                    // 尝试生成Mermaid图表
+                    let mermaidDiagram = null;
+                    if (result.Data.Schema &&
+                        jsonSchemaToMermaid &&
+                        simplifiedSchema &&
+                        !simplifiedSchema.error) {
+                        try {
+                            const mainSchema = JSON.parse(result.Data.Schema);
+                            const schemasMap = {
+                                [name]: mainSchema,
+                            };
+                            // 获取关联模型的 schema
+                            if (simplifiedSchema.relations &&
+                                simplifiedSchema.relations.length > 0) {
+                                const relatedModelNames = [
+                                    ...new Set(simplifiedSchema.relations.map((rel) => rel.targetModel)),
+                                ];
+                                for (const relatedModelName of relatedModelNames) {
+                                    try {
+                                        const relatedResult = await cloudbase
+                                            .commonService("lowcode")
+                                            .call({
+                                            Action: "DescribeBasicDataSource",
+                                            Param: {
+                                                EnvId: currentEnvId,
+                                                Name: relatedModelName,
+                                            },
+                                        });
+                                        if (relatedResult.Data && relatedResult.Data.Schema) {
+                                            schemasMap[relatedModelName] = JSON.parse(relatedResult.Data.Schema);
                                         }
                                     }
+                                    catch (e) {
+                                        console.warn(`获取关联模型 ${relatedModelName} 的 schema 失败:`, e);
+                                    }
                                 }
-                                // 调用 jsonSchemaToMermaid，传入正确的参数格式
-                                mermaidDiagram = jsonSchemaToMermaid(schemasMap);
-                            }
-                            catch (e) {
-                                console.warn("生成Mermaid图表失败:", e);
                             }
+                            // 调用 jsonSchemaToMermaid，传入正确的参数格式
+                            mermaidDiagram = jsonSchemaToMermaid(schemasMap);
                         }
-                        const simplifiedModel = {
-                            DbInstanceType: result.Data.DbInstanceType,
-                            Title: result.Data.Title,
-                            Description: result.Data.Description,
-                            Name: result.Data.Name,
-                            UpdatedAt: result.Data.UpdatedAt,
-                            Schema: simplifiedSchema,
-                            mermaid: mermaidDiagram,
-                        };
+                        catch (e) {
+                            console.warn("生成Mermaid图表失败:", e);
+                        }
+                    }
+                    const simplifiedModel = {
+                        DbInstanceType: result.Data.DbInstanceType,
+                        Title: result.Data.Title,
+                        Description: result.Data.Description,
+                        Name: result.Data.Name,
+                        UpdatedAt: result.Data.UpdatedAt,
+                        Schema: simplifiedSchema,
+                        mermaid: mermaidDiagram,
+                    };
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    success: true,
+                                    action: "get",
+                                    data: simplifiedModel,
+                                    message: "获取数据模型成功",
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    if (error.original?.Code === "ResourceNotFound") {
                         return {
                             content: [
                                 {
                                     type: "text",
                                     text: JSON.stringify({
-                                        success: true,
+                                        success: false,
                                         action: "get",
-                                        data: simplifiedModel,
-                                        message: "获取数据模型成功",
+                                        error: "ResourceNotFound",
+                                        message: `数据模型 ${name} 不存在`,
                                     }, null, 2),
                                 },
                             ],
                         };
                     }
-                    catch (error) {
-                        if (error.original?.Code === "ResourceNotFound") {
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            success: false,
-                                            action: "get",
-                                            error: "ResourceNotFound",
-                                            message: `数据模型 ${name} 不存在`,
-                                        }, null, 2),
-                                    },
-                                ],
-                            };
-                        }
-                        throw error;
-                    }
-                case "list":
-                    // 构建请求参数
-                    const listParams = {
-                        EnvId: currentEnvId,
-                        PageIndex: 1,
-                        PageSize: 1000,
-                        QuerySystemModel: true, // 查询系统模型
-                        QueryConnector: 0, // 0 表示数据模型
-                    };
-                    // 只有当 names 参数存在且不为空时才添加过滤条件
-                    if (names && names.length > 0) {
-                        listParams.DataSourceNames = names;
-                    }
+                    throw error;
+                }
+            case "list":
+                // 构建请求参数
+                const listParams = {
+                    EnvId: currentEnvId,
+                    PageIndex: 1,
+                    PageSize: 1000,
+                    QuerySystemModel: true, // 查询系统模型
+                    QueryConnector: 0, // 0 表示数据模型
+                };
+                // 只有当 names 参数存在且不为空时才添加过滤条件
+                if (names && names.length > 0) {
+                    listParams.DataSourceNames = names;
+                }
+                result = await cloudbase.commonService("lowcode").call({
+                    Action: "DescribeDataSourceList",
+                    Param: listParams,
+                });
+                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+                const models = result.Data?.Rows || [];
+                // 只保留基础字段，list操作不返回Schema
+                const simplifiedModels = models.map((model) => ({
+                    DbInstanceType: model.DbInstanceType,
+                    Title: model.Title,
+                    Description: model.Description,
+                    Name: model.Name,
+                    UpdatedAt: model.UpdatedAt,
+                }));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                action: "list",
+                                data: simplifiedModels,
+                                count: simplifiedModels.length,
+                                message: "获取数据模型列表成功",
+                            }, null, 2),
+                        },
+                    ],
+                };
+            case "docs":
+                if (!name) {
+                    throw new Error("生成SDK文档需要提供模型名称");
+                }
+                try {
+                    // 先获取模型信息
                     result = await cloudbase.commonService("lowcode").call({
-                        Action: "DescribeDataSourceList",
-                        Param: listParams,
+                        Action: "DescribeBasicDataSource",
+                        Param: {
+                            EnvId: currentEnvId,
+                            Name: name,
+                        },
                     });
                     (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                    const models = result.Data?.Rows || [];
-                    // 只保留基础字段，list操作不返回Schema
-                    const simplifiedModels = models.map((model) => ({
-                        DbInstanceType: model.DbInstanceType,
-                        Title: model.Title,
-                        Description: model.Description,
-                        Name: model.Name,
-                        UpdatedAt: model.UpdatedAt,
-                    }));
+                    if (!result.Data) {
+                        throw new Error(`数据模型 ${name} 不存在`);
+                    }
+                    // 解析Schema获取字段信息
+                    let userFields = [];
+                    let relations = [];
+                    if (result.Data.Schema) {
+                        try {
+                            const schema = JSON.parse(result.Data.Schema);
+                            const properties = schema.properties || {};
+                            // 提取用户定义的字段
+                            userFields = Object.keys(properties)
+                                .filter((key) => !properties[key]["x-system"])
+                                .map((key) => {
+                                const field = properties[key];
+                                return parseFieldStructure(field, key, schema);
+                            });
+                            // 提取关联关系
+                            relations = userFields
+                                .filter((field) => field.linkage)
+                                .map((field) => ({
+                                field: field.name,
+                                type: field.format,
+                                title: field.title,
+                                targetModel: field.linkage.parentDataSourceName,
+                                foreignKey: field.linkage.parentFieldKey,
+                                displayField: field.linkage.parentFieldTitle,
+                            }));
+                        }
+                        catch (e) {
+                            // Schema解析失败，使用空数组
+                            console.error("Schema解析失败", e);
+                        }
+                    }
+                    // 生成SDK使用文档
+                    const docs = generateSDKDocs(result.Data.Name, result.Data.Title, userFields, relations);
                     return {
                         content: [
                             {
                                 type: "text",
                                 text: JSON.stringify({
                                     success: true,
-                                    action: "list",
-                                    data: simplifiedModels,
-                                    count: simplifiedModels.length,
-                                    message: "获取数据模型列表成功",
+                                    action: "docs",
+                                    modelName: name,
+                                    modelTitle: result.Data.Title,
+                                    docs,
+                                    message: "SDK使用文档生成成功",
                                 }, null, 2),
                             },
                         ],
                     };
-                case "docs":
-                    if (!name) {
-                        throw new Error("生成SDK文档需要提供模型名称");
-                    }
-                    try {
-                        // 先获取模型信息
-                        result = await cloudbase.commonService("lowcode").call({
-                            Action: "DescribeBasicDataSource",
-                            Param: {
-                                EnvId: currentEnvId,
-                                Name: name,
-                            },
-                        });
-                        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                        if (!result.Data) {
-                            throw new Error(`数据模型 ${name} 不存在`);
-                        }
-                        // 解析Schema获取字段信息
-                        let userFields = [];
-                        let relations = [];
-                        if (result.Data.Schema) {
-                            try {
-                                const schema = JSON.parse(result.Data.Schema);
-                                const properties = schema.properties || {};
-                                // 提取用户定义的字段
-                                userFields = Object.keys(properties)
-                                    .filter((key) => !properties[key]["x-system"])
-                                    .map((key) => {
-                                    const field = properties[key];
-                                    return parseFieldStructure(field, key, schema);
-                                });
-                                // 提取关联关系
-                                relations = userFields
-                                    .filter((field) => field.linkage)
-                                    .map((field) => ({
-                                    field: field.name,
-                                    type: field.format,
-                                    title: field.title,
-                                    targetModel: field.linkage.parentDataSourceName,
-                                    foreignKey: field.linkage.parentFieldKey,
-                                    displayField: field.linkage.parentFieldTitle,
-                                }));
-                            }
-                            catch (e) {
-                                // Schema解析失败，使用空数组
-                                console.error("Schema解析失败", e);
-                            }
-                        }
-                        // 生成SDK使用文档
-                        const docs = generateSDKDocs(result.Data.Name, result.Data.Title, userFields, relations);
+                }
+                catch (error) {
+                    if (error.original?.Code === "ResourceNotFound") {
                         return {
                             content: [
                                 {
                                     type: "text",
                                     text: JSON.stringify({
-                                        success: true,
+                                        success: false,
                                         action: "docs",
-                                        modelName: name,
-                                        modelTitle: result.Data.Title,
-                                        docs,
-                                        message: "SDK使用文档生成成功",
+                                        error: "ResourceNotFound",
+                                        message: `数据模型 ${name} 不存在`,
                                     }, null, 2),
                                 },
                             ],
                         };
                     }
-                    catch (error) {
-                        if (error.original?.Code === "ResourceNotFound") {
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            success: false,
-                                            action: "docs",
-                                            error: "ResourceNotFound",
-                                            message: `数据模型 ${name} 不存在`,
-                                        }, null, 2),
-                                    },
-                                ],
-                            };
-                        }
-                        throw error;
-                    }
-                default:
-                    throw new Error(`不支持的操作类型: ${action}`);
-            }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            action,
-                            error: error.message || error.original?.Message || "未知错误",
-                            code: error.original?.Code,
-                            message: "数据模型操作失败",
-                        }, null, 2),
-                    },
-                ],
-            };
+                    throw error;
+                }
+            default:
+                throw new Error(`不支持的操作类型: ${action}`);
         }
     });
     // modifyDataModel - 数据模型修改工具（创建/更新）
@@ -6557,126 +6556,108 @@ classDiagram
             category: "database",
         },
     }, async ({ mermaidDiagram, action = "create", publish = false, dbInstanceType = "MYSQL", }) => {
-        try {
-            const cloudbase = await getManager();
-            let currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            // 使用mermaidToJsonSchema转换Mermaid图表
-            const schemas = mermaidToJsonSchema(mermaidDiagram);
-            if (!schemas || Object.keys(schemas).length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: false,
-                                error: "No schemas generated from Mermaid diagram",
-                                message: "无法从Mermaid图表生成数据模型Schema",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // 创建数据模型列表
-            const createDataModelList = Object.entries(schemas).map(([name, schema]) => {
-                return {
-                    CreateSource: "cloudbase_create",
-                    Creator: null,
-                    DbLinkName: null,
-                    Description: schema.description ||
-                        `${schema.title || name}数据模型`,
-                    Schema: JSON.stringify(createBackendSchemaParams(schema)),
-                    Title: schema.title || name,
-                    Name: name,
-                    TableNameRule: "only_name",
-                };
-            });
-            // 调用批量创建数据模型API
-            const result = await cloudbase.commonService("lowcode").call({
-                Action: "BatchCreateDataModelList",
-                Param: {
-                    CreateDataModelList: createDataModelList,
-                    Creator: null,
-                    DbInstanceType: dbInstanceType,
-                    EnvId: currentEnvId,
-                },
-            });
-            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            const taskId = result.Data?.TaskId;
-            if (!taskId) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: false,
-                                requestId: result.RequestId,
-                                error: "No TaskId returned",
-                                message: "创建任务失败，未返回任务ID",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // 轮询任务状态直至完成或超时
-            const maxWaitTime = 30000; // 30秒超时
-            const startTime = Date.now();
-            let status = "init";
-            let statusResult = null;
-            while (status === "init" && Date.now() - startTime < maxWaitTime) {
-                await new Promise((resolve) => setTimeout(resolve, 2000)); // 等待2秒
-                statusResult = await cloudbase.commonService("lowcode").call({
-                    Action: "QueryModelTaskStatus",
-                    Param: {
-                        EnvId: currentEnvId,
-                        TaskId: taskId,
-                    },
-                });
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, statusResult);
-                status = statusResult.Data?.Status || "init";
-            }
-            // 返回最终结果
-            const models = Object.keys(schemas);
-            const successModels = statusResult?.Data?.SuccessResourceIdList || [];
-            const failedModels = models.filter((model) => !successModels.includes(model));
+        const cloudbase = await getManager();
+        let currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        const schemas = mermaidToJsonSchema(mermaidDiagram);
+        if (!schemas || Object.keys(schemas).length === 0) {
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            success: status === "success",
-                            requestId: result.RequestId,
-                            taskId: taskId,
-                            models: models,
-                            successModels: successModels,
-                            failedModels: failedModels,
-                            status: status,
-                            action: action,
-                            message: status === "success"
-                                ? `数据模型${action === "create" ? "创建" : "更新"}成功，共处理${models.length}个模型`
-                                : status === "init"
-                                    ? `任务超时，任务ID: ${taskId}，请稍后手动查询状态`
-                                    : `数据模型${action === "create" ? "创建" : "更新"}失败`,
-                            taskResult: statusResult?.Data,
+                            success: false,
+                            error: "No schemas generated from Mermaid diagram",
+                            message: "无法从Mermaid图表生成数据模型Schema",
                         }, null, 2),
                     },
                 ],
             };
         }
-        catch (error) {
+        // 创建数据模型列表
+        const createDataModelList = Object.entries(schemas).map(([name, schema]) => {
+            return {
+                CreateSource: "cloudbase_create",
+                Creator: null,
+                DbLinkName: null,
+                Description: schema.description ||
+                    `${schema.title || name}数据模型`,
+                Schema: JSON.stringify(createBackendSchemaParams(schema)),
+                Title: schema.title || name,
+                Name: name,
+                TableNameRule: "only_name",
+            };
+        });
+        // 调用批量创建数据模型API
+        const result = await cloudbase.commonService("lowcode").call({
+            Action: "BatchCreateDataModelList",
+            Param: {
+                CreateDataModelList: createDataModelList,
+                Creator: null,
+                DbInstanceType: dbInstanceType,
+                EnvId: currentEnvId,
+            },
+        });
+        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        const taskId = result.Data?.TaskId;
+        if (!taskId) {
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
                             success: false,
-                            error: error.message || error.original?.Message || "未知错误",
-                            code: error.original?.Code,
-                            message: "数据模型修改操作失败",
+                            requestId: result.RequestId,
+                            error: "No TaskId returned",
+                            message: "创建任务失败，未返回任务ID",
                         }, null, 2),
                     },
                 ],
             };
         }
+        // 轮询任务状态直至完成或超时
+        const maxWaitTime = 30000; // 30秒超时
+        const startTime = Date.now();
+        let status = "init";
+        let statusResult = null;
+        while (status === "init" && Date.now() - startTime < maxWaitTime) {
+            await new Promise((resolve) => setTimeout(resolve, 2000)); // 等待2秒
+            statusResult = await cloudbase.commonService("lowcode").call({
+                Action: "QueryModelTaskStatus",
+                Param: {
+                    EnvId: currentEnvId,
+                    TaskId: taskId,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, statusResult);
+            status = statusResult.Data?.Status || "init";
+        }
+        // 返回最终结果
+        const models = Object.keys(schemas);
+        const successModels = statusResult?.Data?.SuccessResourceIdList || [];
+        const failedModels = models.filter((model) => !successModels.includes(model));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: status === "success",
+                        requestId: result.RequestId,
+                        taskId: taskId,
+                        models: models,
+                        successModels: successModels,
+                        failedModels: failedModels,
+                        status: status,
+                        action: action,
+                        message: status === "success"
+                            ? `数据模型${action === "create" ? "创建" : "更新"}成功，共处理${models.length}个模型`
+                            : status === "init"
+                                ? `任务超时，任务ID: ${taskId}，请稍后手动查询状态`
+                                : `数据模型${action === "create" ? "创建" : "更新"}失败`,
+                        taskResult: statusResult?.Data,
+                    }, null, 2),
+                },
+            ],
+        };
     });
 }
 
@@ -7491,41 +7472,25 @@ function registerInviteCodeTools(server) {
                 ]
             };
         }
-        try {
-            const manager = await getManager();
-            const EnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            const result = await manager.commonService().call({
-                Action: 'ActivateInviteCode',
-                Param: { InviteCode, EnvId }
-            });
-            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            ErrorCode: result?.ErrorCode || '',
-                            ErrorMsg: result?.ErrorMsg || '',
-                            RequestId: result?.RequestId || ''
-                        }, null, 2)
-                    }
-                ]
-            };
-        }
-        catch (e) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            ErrorCode: e.code || 'Exception',
-                            ErrorMsg: '激活失败：' + e.message,
-                            RequestId: e.RequestId || ''
-                        }, null, 2)
-                    }
-                ]
-            };
-        }
+        const manager = await getManager();
+        const EnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        const result = await manager.commonService().call({
+            Action: 'ActivateInviteCode',
+            Param: { InviteCode, EnvId }
+        });
+        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        ErrorCode: result?.ErrorCode || '',
+                        ErrorMsg: result?.ErrorMsg || '',
+                        RequestId: result?.RequestId || ''
+                    }, null, 2)
+                }
+            ]
+        };
     });
 }
 
@@ -7570,94 +7535,78 @@ function registerStorageTools(server) {
             category: "storage"
         }
     }, async (args) => {
-        try {
-            const input = args;
-            const manager = await getManager();
-            if (!manager) {
-                throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
-            }
-            const storageService = manager.storage;
-            switch (input.action) {
-                case 'list': {
-                    const result = await storageService.listDirectoryFiles(input.cloudPath);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'list',
-                                        cloudPath: input.cloudPath,
-                                        files: result || [],
-                                        totalCount: result?.length || 0
-                                    },
-                                    message: `Successfully listed ${result?.length || 0} files in directory '${input.cloudPath}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
-                }
-                case 'info': {
-                    const result = await storageService.getFileInfo(input.cloudPath);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'info',
-                                        cloudPath: input.cloudPath,
-                                        fileInfo: result
-                                    },
-                                    message: `Successfully retrieved file info for '${input.cloudPath}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
-                }
-                case 'url': {
-                    const result = await storageService.getTemporaryUrl([{
-                            cloudPath: input.cloudPath,
-                            maxAge: input.maxAge || 3600
-                        }]);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'url',
-                                        cloudPath: input.cloudPath,
-                                        temporaryUrl: result[0]?.url || "",
-                                        expireTime: `${input.maxAge || 3600}秒`,
-                                        fileId: result[0]?.fileId || ""
-                                    },
-                                    message: `Successfully generated temporary URL for '${input.cloudPath}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
-                }
-                default:
-                    throw new Error(`Unsupported action: ${input.action}`);
+        const input = args;
+        const manager = await getManager();
+        if (!manager) {
+            throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
+        }
+        const storageService = manager.storage;
+        switch (input.action) {
+            case 'list': {
+                const result = await storageService.listDirectoryFiles(input.cloudPath);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'list',
+                                    cloudPath: input.cloudPath,
+                                    files: result || [],
+                                    totalCount: result?.length || 0
+                                },
+                                message: `Successfully listed ${result?.length || 0} files in directory '${input.cloudPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'info': {
+                const result = await storageService.getFileInfo(input.cloudPath);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'info',
+                                    cloudPath: input.cloudPath,
+                                    fileInfo: result
+                                },
+                                message: `Successfully retrieved file info for '${input.cloudPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'url': {
+                const result = await storageService.getTemporaryUrl([{
+                        cloudPath: input.cloudPath,
+                        maxAge: input.maxAge || 3600
+                    }]);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'url',
+                                    cloudPath: input.cloudPath,
+                                    temporaryUrl: result[0]?.url || "",
+                                    expireTime: `${input.maxAge || 3600}秒`,
+                                    fileId: result[0]?.fileId || ""
+                                },
+                                message: `Successfully generated temporary URL for '${input.cloudPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
             }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message || 'Unknown error occurred',
-                            message: `Failed to query storage information. Please check your permissions and parameters.`
-                        }, null, 2)
-                    }
-                ]
-            };
+            default:
+                throw new Error(`Unsupported action: ${input.action}`);
         }
     });
     // Tool 2: manageStorage - 管理存储文件（写操作）
@@ -7673,151 +7622,128 @@ function registerStorageTools(server) {
             category: "storage"
         }
     }, async (args) => {
-        try {
-            const input = args;
-            const manager = await getManager();
-            if (!manager) {
-                throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
-            }
-            const storageService = manager.storage;
-            switch (input.action) {
-                case 'upload': {
-                    if (input.isDirectory) {
-                        // 上传目录
-                        await storageService.uploadDirectory({
-                            localPath: input.localPath,
-                            cloudPath: input.cloudPath,
-                            onProgress: (progressData) => {
-                                console.log("Upload directory progress:", progressData);
-                            }
-                        });
-                    }
-                    else {
-                        // 上传文件
-                        await storageService.uploadFile({
-                            localPath: input.localPath,
-                            cloudPath: input.cloudPath,
-                            onProgress: (progressData) => {
-                                console.log("Upload file progress:", progressData);
-                            }
-                        });
-                    }
-                    // 获取文件临时下载地址
-                    const fileUrls = await storageService.getTemporaryUrl([{
-                            cloudPath: input.cloudPath,
-                            maxAge: 3600 // 临时链接有效期1小时
-                        }]);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'upload',
-                                        localPath: input.localPath,
-                                        cloudPath: input.cloudPath,
-                                        isDirectory: input.isDirectory,
-                                        temporaryUrl: fileUrls[0]?.url || "",
-                                        expireTime: "1小时"
-                                    },
-                                    message: `Successfully uploaded ${input.isDirectory ? 'directory' : 'file'} from '${input.localPath}' to '${input.cloudPath}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+        const input = args;
+        const manager = await getManager();
+        if (!manager) {
+            throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
+        }
+        const storageService = manager.storage;
+        switch (input.action) {
+            case 'upload': {
+                if (input.isDirectory) {
+                    await storageService.uploadDirectory({
+                        localPath: input.localPath,
+                        cloudPath: input.cloudPath,
+                        onProgress: (progressData) => {
+                            console.log("Upload directory progress:", progressData);
+                        }
+                    });
                 }
-                case 'download': {
-                    if (input.isDirectory) {
-                        // 下载目录
-                        await storageService.downloadDirectory({
-                            cloudPath: input.cloudPath,
-                            localPath: input.localPath
-                        });
-                    }
-                    else {
-                        // 下载文件
-                        await storageService.downloadFile({
-                            cloudPath: input.cloudPath,
-                            localPath: input.localPath
-                        });
-                    }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'download',
-                                        cloudPath: input.cloudPath,
-                                        localPath: input.localPath,
-                                        isDirectory: input.isDirectory
-                                    },
-                                    message: `Successfully downloaded ${input.isDirectory ? 'directory' : 'file'} from '${input.cloudPath}' to '${input.localPath}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+                else {
+                    await storageService.uploadFile({
+                        localPath: input.localPath,
+                        cloudPath: input.cloudPath,
+                        onProgress: (progressData) => {
+                            console.log("Upload file progress:", progressData);
+                        }
+                    });
                 }
-                case 'delete': {
-                    if (!input.force) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        success: false,
-                                        error: "Delete operation requires confirmation",
-                                        message: "Please set force: true to confirm deletion. This action cannot be undone."
-                                    }, null, 2)
-                                }
-                            ]
-                        };
-                    }
-                    if (input.isDirectory) {
-                        // 删除目录
-                        await storageService.deleteDirectory(input.cloudPath);
-                    }
-                    else {
-                        // 删除文件
-                        await storageService.deleteFile([input.cloudPath]);
-                    }
+                const fileUrls = await storageService.getTemporaryUrl([{
+                        cloudPath: input.cloudPath,
+                        maxAge: 3600
+                    }]);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'upload',
+                                    localPath: input.localPath,
+                                    cloudPath: input.cloudPath,
+                                    isDirectory: input.isDirectory,
+                                    temporaryUrl: fileUrls[0]?.url || "",
+                                    expireTime: "1小时"
+                                },
+                                message: `Successfully uploaded ${input.isDirectory ? 'directory' : 'file'} from '${input.localPath}' to '${input.cloudPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'download': {
+                if (input.isDirectory) {
+                    await storageService.downloadDirectory({
+                        cloudPath: input.cloudPath,
+                        localPath: input.localPath
+                    });
+                }
+                else {
+                    await storageService.downloadFile({
+                        cloudPath: input.cloudPath,
+                        localPath: input.localPath
+                    });
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'download',
+                                    cloudPath: input.cloudPath,
+                                    localPath: input.localPath,
+                                    isDirectory: input.isDirectory
+                                },
+                                message: `Successfully downloaded ${input.isDirectory ? 'directory' : 'file'} from '${input.cloudPath}' to '${input.localPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'delete': {
+                if (!input.force) {
                     return {
                         content: [
                             {
                                 type: "text",
                                 text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        action: 'delete',
-                                        cloudPath: input.cloudPath,
-                                        isDirectory: input.isDirectory,
-                                        deleted: true
-                                    },
-                                    message: `Successfully deleted ${input.isDirectory ? 'directory' : 'file'} '${input.cloudPath}'`
+                                    success: false,
+                                    error: "Delete operation requires confirmation",
+                                    message: "Please set force: true to confirm deletion. This action cannot be undone."
                                 }, null, 2)
                             }
                         ]
                     };
                 }
-                default:
-                    throw new Error(`Unsupported action: ${input.action}`);
+                if (input.isDirectory) {
+                    await storageService.deleteDirectory(input.cloudPath);
+                }
+                else {
+                    await storageService.deleteFile([input.cloudPath]);
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    action: 'delete',
+                                    cloudPath: input.cloudPath,
+                                    isDirectory: input.isDirectory,
+                                    deleted: true
+                                },
+                                message: `Successfully deleted ${input.isDirectory ? 'directory' : 'file'} '${input.cloudPath}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
             }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message || 'Unknown error occurred',
-                            message: `Failed to manage storage. Please check your permissions and parameters.`
-                        }, null, 2)
-                    }
-                ]
-            };
+            default:
+                throw new Error(`Unsupported action: ${input.action}`);
         }
     });
 }
@@ -7991,113 +7917,97 @@ function registerCloudRunTools(server) {
             category: "cloudrun"
         }
     }, async (args) => {
-        try {
-            const input = args;
-            const manager = await getManager();
-            if (!manager) {
-                throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
-            }
-            const cloudrunService = manager.cloudrun;
-            switch (input.action) {
-                case 'list': {
-                    const listParams = {
-                        pageSize: input.pageSize,
-                        pageNum: input.pageNum,
-                    };
-                    if (input.serverName) {
-                        listParams.serverName = input.serverName;
-                    }
-                    if (input.serverType) {
-                        listParams.serverType = input.serverType;
-                    }
-                    const result = await cloudrunService.list(listParams);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        services: result.ServerList || [],
-                                        pagination: {
-                                            total: result.Total || 0,
-                                            pageSize: input.pageSize,
-                                            pageNum: input.pageNum,
-                                            totalPages: Math.ceil((result.Total || 0) / (input.pageSize || 10))
-                                        }
-                                    },
-                                    message: `Found ${result.ServerList?.length || 0} CloudRun services`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+        const input = args;
+        const manager = await getManager();
+        if (!manager) {
+            throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
+        }
+        const cloudrunService = manager.cloudrun;
+        switch (input.action) {
+            case 'list': {
+                const listParams = {
+                    pageSize: input.pageSize,
+                    pageNum: input.pageNum,
+                };
+                if (input.serverName) {
+                    listParams.serverName = input.serverName;
                 }
-                case 'detail': {
-                    const serverName = input.detailServerName || input.serverName;
-                    const result = await cloudrunService.detail({ serverName });
-                    if (!result) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        success: false,
-                                        error: `Service '${serverName}' not found`,
-                                        message: "Please check the service name and try again."
-                                    }, null, 2)
-                                }
-                            ]
-                        };
-                    }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        service: result
-                                    },
-                                    message: `Retrieved details for service '${serverName}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+                if (input.serverType) {
+                    listParams.serverType = input.serverType;
                 }
-                case 'templates': {
-                    const result = await cloudrunService.getTemplates();
+                const result = await cloudrunService.list(listParams);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    services: result.ServerList || [],
+                                    pagination: {
+                                        total: result.Total || 0,
+                                        pageSize: input.pageSize,
+                                        pageNum: input.pageNum,
+                                        totalPages: Math.ceil((result.Total || 0) / (input.pageSize || 10))
+                                    }
+                                },
+                                message: `Found ${result.ServerList?.length || 0} CloudRun services`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'detail': {
+                const serverName = input.detailServerName || input.serverName;
+                const result = await cloudrunService.detail({ serverName });
+                if (!result) {
                     return {
                         content: [
                             {
                                 type: "text",
                                 text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        templates: result || []
-                                    },
-                                    message: `Found ${result?.length || 0} available templates`
+                                    success: false,
+                                    error: `Service '${serverName}' not found`,
+                                    message: "Please check the service name and try again."
                                 }, null, 2)
                             }
                         ]
                     };
                 }
-                default:
-                    throw new Error(`Unsupported action: ${input.action}`);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    service: result
+                                },
+                                message: `Retrieved details for service '${serverName}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
             }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message || 'Unknown error occurred',
-                            message: "Failed to query CloudRun information. Please check your permissions and try again."
-                        }, null, 2)
-                    }
-                ]
-            };
+            case 'templates': {
+                const result = await cloudrunService.getTemplates();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    templates: result || []
+                                },
+                                message: `Found ${result?.length || 0} available templates`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            default:
+                throw new Error(`Unsupported action: ${input.action}`);
         }
     });
     // Track local running processes for CloudRun function services
@@ -8115,62 +8025,60 @@ function registerCloudRunTools(server) {
             category: "cloudrun"
         }
     }, async (args) => {
-        try {
-            const input = args;
-            const manager = await getManager();
-            if (!manager) {
-                throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
-            }
-            const cloudrunService = manager.cloudrun;
-            let targetPath;
-            // Validate and normalize path for operations that require it
-            if (input.targetPath) {
-                targetPath = validateAndNormalizePath(input.targetPath);
-            }
-            switch (input.action) {
-                case 'createAgent': {
-                    if (!targetPath) {
-                        throw new Error("targetPath is required for createAgent operation");
-                    }
-                    if (!input.agentConfig) {
-                        throw new Error("agentConfig is required for createAgent operation");
-                    }
-                    const { agentName, botTag, description, template = 'blank' } = input.agentConfig;
-                    // Generate BotId
-                    const botId = botTag ? `ibot-${agentName}-${botTag}` : `ibot-${agentName}-${Date.now()}`;
-                    // Create Agent using CloudBase Manager
-                    const agentResult = await manager.agent.createFunctionAgent(targetPath, {
-                        Name: agentName,
-                        BotId: botId,
-                        Introduction: description || `Agent created by ${agentName}`,
-                        Avatar: undefined
-                    });
-                    // Create project directory
-                    const projectDir = path_1.default.join(targetPath, input.serverName);
-                    if (!fs_1.default.existsSync(projectDir)) {
-                        fs_1.default.mkdirSync(projectDir, { recursive: true });
+        const input = args;
+        const manager = await getManager();
+        if (!manager) {
+            throw new Error("Failed to initialize CloudBase manager. Please check your credentials and environment configuration.");
+        }
+        const cloudrunService = manager.cloudrun;
+        let targetPath;
+        if (input.targetPath) {
+            targetPath = validateAndNormalizePath(input.targetPath);
+        }
+        switch (input.action) {
+            case 'createAgent': {
+                if (!targetPath) {
+                    throw new Error("targetPath is required for createAgent operation");
+                }
+                if (!input.agentConfig) {
+                    throw new Error("agentConfig is required for createAgent operation");
+                }
+                const { agentName, botTag, description, template = 'blank' } = input.agentConfig;
+                // Generate BotId
+                const botId = botTag ? `ibot-${agentName}-${botTag}` : `ibot-${agentName}-${Date.now()}`;
+                // Create Agent using CloudBase Manager
+                const agentResult = await manager.agent.createFunctionAgent(targetPath, {
+                    Name: agentName,
+                    BotId: botId,
+                    Introduction: description || `Agent created by ${agentName}`,
+                    Avatar: undefined
+                });
+                // Create project directory
+                const projectDir = path_1.default.join(targetPath, input.serverName);
+                if (!fs_1.default.existsSync(projectDir)) {
+                    fs_1.default.mkdirSync(projectDir, { recursive: true });
+                }
+                // Generate package.json
+                const packageJson = {
+                    name: input.serverName,
+                    version: "1.0.0",
+                    description: description || `Agent created by ${agentName}`,
+                    main: "index.js",
+                    scripts: {
+                        "dev": "tcb cloudrun run --runMode=agent -w",
+                        "deploy": "tcb cloudrun deploy",
+                        "start": "node index.js"
+                    },
+                    dependencies: {
+                        "@cloudbase/aiagent-framework": "^1.0.0-beta.10"
+                    },
+                    devDependencies: {
+                        "@cloudbase/cli": "^2.6.16"
                     }
-                    // Generate package.json
-                    const packageJson = {
-                        name: input.serverName,
-                        version: "1.0.0",
-                        description: description || `Agent created by ${agentName}`,
-                        main: "index.js",
-                        scripts: {
-                            "dev": "tcb cloudrun run --runMode=agent -w",
-                            "deploy": "tcb cloudrun deploy",
-                            "start": "node index.js"
-                        },
-                        dependencies: {
-                            "@cloudbase/aiagent-framework": "^1.0.0-beta.10"
-                        },
-                        devDependencies: {
-                            "@cloudbase/cli": "^2.6.16"
-                        }
-                    };
-                    fs_1.default.writeFileSync(path_1.default.join(projectDir, 'package.json'), JSON.stringify(packageJson, null, 2));
-                    // Generate index.js with Agent template
-                    const indexJsContent = `const { IBot } = require("@cloudbase/aiagent-framework");
+                };
+                fs_1.default.writeFileSync(path_1.default.join(projectDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+                // Generate index.js with Agent template
+                const indexJsContent = `const { IBot } = require("@cloudbase/aiagent-framework");
 const { BotRunner } = require("@cloudbase/aiagent-framework");
 
 const ANSWER = "你好，我是一个智能体，但我只会说这一句话。";
@@ -8215,18 +8123,18 @@ exports.main = function (event, context) {
   return BotRunner.run(event, context, new MyBot(context));
 };
 `;
-                    fs_1.default.writeFileSync(path_1.default.join(projectDir, 'index.js'), indexJsContent);
-                    // Generate cloudbaserc.json
-                    const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-                    const cloudbasercContent = {
-                        envId: currentEnvId,
-                        cloudrun: {
-                            name: input.serverName
-                        }
-                    };
-                    fs_1.default.writeFileSync(path_1.default.join(projectDir, 'cloudbaserc.json'), JSON.stringify(cloudbasercContent, null, 2));
-                    // Generate README.md
-                    const readmeContent = `# ${agentName} Agent
+                fs_1.default.writeFileSync(path_1.default.join(projectDir, 'index.js'), indexJsContent);
+                // Generate cloudbaserc.json
+                const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                const cloudbasercContent = {
+                    envId: currentEnvId,
+                    cloudrun: {
+                        name: input.serverName
+                    }
+                };
+                fs_1.default.writeFileSync(path_1.default.join(projectDir, 'cloudbaserc.json'), JSON.stringify(cloudbasercContent, null, 2));
+                // Generate README.md
+                const readmeContent = `# ${agentName} Agent
 
 这是一个基于函数型云托管的 AI 智能体。
 
@@ -8271,230 +8179,230 @@ for await (let x of res.textStream) {
 </script>
 \`\`\`
 `;
-                    fs_1.default.writeFileSync(path_1.default.join(projectDir, 'README.md'), readmeContent);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        agentName: agentName,
-                                        botId: botId,
-                                        projectDir: projectDir,
-                                        serverName: input.serverName,
-                                        template: template,
-                                        filesCreated: ['package.json', 'index.js', 'cloudbaserc.json', 'README.md']
-                                    },
-                                    message: `Successfully created Agent '${agentName}' with BotId '${botId}' in ${projectDir}`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+                fs_1.default.writeFileSync(path_1.default.join(projectDir, 'README.md'), readmeContent);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    agentName: agentName,
+                                    botId: botId,
+                                    projectDir: projectDir,
+                                    serverName: input.serverName,
+                                    template: template,
+                                    filesCreated: ['package.json', 'index.js', 'cloudbaserc.json', 'README.md']
+                                },
+                                message: `Successfully created Agent '${agentName}' with BotId '${botId}' in ${projectDir}`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'deploy': {
+                if (!targetPath) {
+                    throw new Error("targetPath is required for deploy operation");
                 }
-                case 'deploy': {
-                    if (!targetPath) {
-                        throw new Error("targetPath is required for deploy operation");
-                    }
-                    // Determine service type - use input.serverType if provided, otherwise auto-detect
-                    let serverType;
-                    if (input.serverType) {
-                        serverType = input.serverType;
+                // Determine service type - use input.serverType if provided, otherwise auto-detect
+                let serverType;
+                if (input.serverType) {
+                    serverType = input.serverType;
+                }
+                else {
+                    try {
+                        // First try to get existing service details
+                        const details = await cloudrunService.detail({ serverName: input.serverName });
+                        serverType = details.BaseInfo?.ServerType || 'container';
                     }
-                    else {
-                        try {
-                            // First try to get existing service details
-                            const details = await cloudrunService.detail({ serverName: input.serverName });
-                            serverType = details.BaseInfo?.ServerType || 'container';
+                    catch (e) {
+                        // If service doesn't exist, determine by project structure
+                        const dockerfilePath = path_1.default.join(targetPath, 'Dockerfile');
+                        if (fs_1.default.existsSync(dockerfilePath)) {
+                            serverType = 'container';
                         }
-                        catch (e) {
-                            // If service doesn't exist, determine by project structure
-                            const dockerfilePath = path_1.default.join(targetPath, 'Dockerfile');
-                            if (fs_1.default.existsSync(dockerfilePath)) {
-                                serverType = 'container';
-                            }
-                            else {
-                                // Check if it's a Node.js function project (has package.json with specific structure)
-                                const packageJsonPath = path_1.default.join(targetPath, 'package.json');
-                                if (fs_1.default.existsSync(packageJsonPath)) {
-                                    try {
-                                        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
-                                        // If it has function-specific dependencies or scripts, treat as function
-                                        if (packageJson.dependencies?.['@cloudbase/aiagent-framework'] ||
-                                            packageJson.scripts?.['dev']?.includes('cloudrun run')) {
-                                            serverType = 'function';
-                                        }
-                                        else {
-                                            serverType = 'container';
-                                        }
+                        else {
+                            // Check if it's a Node.js function project (has package.json with specific structure)
+                            const packageJsonPath = path_1.default.join(targetPath, 'package.json');
+                            if (fs_1.default.existsSync(packageJsonPath)) {
+                                try {
+                                    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+                                    // If it has function-specific dependencies or scripts, treat as function
+                                    if (packageJson.dependencies?.['@cloudbase/aiagent-framework'] ||
+                                        packageJson.scripts?.['dev']?.includes('cloudrun run')) {
+                                        serverType = 'function';
                                     }
-                                    catch (parseError) {
+                                    else {
                                         serverType = 'container';
                                     }
                                 }
-                                else {
-                                    // No package.json, default to container
+                                catch (parseError) {
                                     serverType = 'container';
                                 }
                             }
-                        }
-                    }
-                    const deployParams = {
-                        serverName: input.serverName,
-                        targetPath: targetPath,
-                        force: input.force,
-                        serverType: serverType,
-                    };
-                    // Add server configuration if provided
-                    if (input.serverConfig) {
-                        deployParams.serverConfig = input.serverConfig;
-                    }
-                    const result = await cloudrunService.deploy(deployParams);
-                    // Generate cloudbaserc.json configuration file
-                    const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-                    const cloudbasercPath = path_1.default.join(targetPath, 'cloudbaserc.json');
-                    const cloudbasercContent = {
-                        envId: currentEnvId,
-                        cloudrun: {
-                            name: input.serverName
-                        }
-                    };
-                    try {
-                        fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
-                    }
-                    catch (error) {
-                        // Ignore cloudbaserc.json creation errors
-                    }
-                    // Send deployment notification to CodeBuddy IDE
-                    try {
-                        // Query service details to get access URL
-                        let serviceUrl = "";
-                        try {
-                            const serviceDetails = await cloudrunService.detail({ serverName: input.serverName });
-                            // Extract access URL from service details
-                            // Priority: DefaultDomainName > CustomDomainName > PublicDomain > InternalDomain
-                            const details = serviceDetails; // Use any to access dynamic properties
-                            if (details?.BaseInfo?.DefaultDomainName) {
-                                // DefaultDomainName is already a complete URL (e.g., https://...)
-                                serviceUrl = details.BaseInfo.DefaultDomainName;
-                            }
-                            else if (details?.BaseInfo?.CustomDomainName) {
-                                // CustomDomainName might be a domain without protocol
-                                const customDomain = details.BaseInfo.CustomDomainName;
-                                serviceUrl = customDomain.startsWith('http') ? customDomain : `https://${customDomain}`;
-                            }
-                            else if (details?.BaseInfo?.PublicDomain) {
-                                serviceUrl = `https://${details.BaseInfo.PublicDomain}`;
-                            }
-                            else if (details?.BaseInfo?.InternalDomain) {
-                                serviceUrl = `https://${details.BaseInfo.InternalDomain}`;
-                            }
-                            else if (details?.AccessInfo?.PublicDomain) {
-                                serviceUrl = `https://${details.AccessInfo.PublicDomain}`;
-                            }
                             else {
-                                serviceUrl = ""; // URL not available
+                                // No package.json, default to container
+                                serverType = 'container';
                             }
                         }
-                        catch (detailErr) {
-                            // If query fails, continue with empty URL
-                            serviceUrl = "";
-                        }
-                        // Extract project name from targetPath
-                        const projectName = path_1.default.basename(targetPath);
-                        // Build console URL
-                        const consoleUrl = `https://tcb.cloud.tencent.com/dev?envId=${currentEnvId}#/platform-run/service/detail?serverName=${input.serverName}&tabId=overview&envId=${currentEnvId}`;
-                        // Send notification
-                        await (0, notification_js_1.sendDeployNotification)(server, {
-                            deployType: 'cloudrun',
-                            url: serviceUrl,
-                            projectId: currentEnvId,
-                            projectName: projectName,
-                            consoleUrl: consoleUrl
-                        });
-                    }
-                    catch (notifyErr) {
-                        // Notification failure should not affect deployment flow
-                        // Error is already logged in sendDeployNotification
                     }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        serviceName: input.serverName,
-                                        status: 'deployed',
-                                        deployPath: targetPath,
-                                        serverType: serverType,
-                                        cloudbasercGenerated: true
-                                    },
-                                    message: `Successfully deployed ${serverType} service '${input.serverName}' from ${targetPath}`
-                                }, null, 2)
-                            }
-                        ]
-                    };
                 }
-                case 'run': {
-                    if (!targetPath) {
-                        throw new Error("targetPath is required for run operation");
-                    }
-                    // Do not support container services locally: basic heuristic - if Dockerfile exists, treat as container
-                    const dockerfilePath = path_1.default.join(targetPath, 'Dockerfile');
-                    if (fs_1.default.existsSync(dockerfilePath)) {
-                        throw new Error("Local run is only supported for function-type CloudRun services. Container services are not supported.");
+                const deployParams = {
+                    serverName: input.serverName,
+                    targetPath: targetPath,
+                    force: input.force,
+                    serverType: serverType,
+                };
+                // Add server configuration if provided
+                if (input.serverConfig) {
+                    deployParams.serverConfig = input.serverConfig;
+                }
+                const result = await cloudrunService.deploy(deployParams);
+                // Generate cloudbaserc.json configuration file
+                const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                const cloudbasercPath = path_1.default.join(targetPath, 'cloudbaserc.json');
+                const cloudbasercContent = {
+                    envId: currentEnvId,
+                    cloudrun: {
+                        name: input.serverName
                     }
-                    // Check if this is an Agent project
-                    const isAgent = checkIfAgentProject(targetPath);
-                    const runMode = input.runOptions?.runMode || (isAgent ? 'agent' : 'normal');
-                    // Check if service is already running and verify process exists
-                    if (runningProcesses.has(input.serverName)) {
-                        const existingPid = runningProcesses.get(input.serverName);
-                        try {
-                            // Check if process actually exists
-                            process.kill(existingPid, 0);
-                            return {
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify({
-                                            success: true,
-                                            data: {
-                                                serviceName: input.serverName,
-                                                status: 'running',
-                                                pid: existingPid,
-                                                cwd: targetPath
-                                            },
-                                            message: `Service '${input.serverName}' is already running locally (pid=${existingPid})`
-                                        }, null, 2)
-                                    }
-                                ]
-                            };
+                };
+                try {
+                    fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
+                }
+                catch (error) {
+                    // Ignore cloudbaserc.json creation errors
+                }
+                // Send deployment notification to CodeBuddy IDE
+                try {
+                    // Query service details to get access URL
+                    let serviceUrl = "";
+                    try {
+                        const serviceDetails = await cloudrunService.detail({ serverName: input.serverName });
+                        // Extract access URL from service details
+                        // Priority: DefaultDomainName > CustomDomainName > PublicDomain > InternalDomain
+                        const details = serviceDetails; // Use any to access dynamic properties
+                        if (details?.BaseInfo?.DefaultDomainName) {
+                            // DefaultDomainName is already a complete URL (e.g., https://...)
+                            serviceUrl = details.BaseInfo.DefaultDomainName;
+                        }
+                        else if (details?.BaseInfo?.CustomDomainName) {
+                            // CustomDomainName might be a domain without protocol
+                            const customDomain = details.BaseInfo.CustomDomainName;
+                            serviceUrl = customDomain.startsWith('http') ? customDomain : `https://${customDomain}`;
+                        }
+                        else if (details?.BaseInfo?.PublicDomain) {
+                            serviceUrl = `https://${details.BaseInfo.PublicDomain}`;
+                        }
+                        else if (details?.BaseInfo?.InternalDomain) {
+                            serviceUrl = `https://${details.BaseInfo.InternalDomain}`;
+                        }
+                        else if (details?.AccessInfo?.PublicDomain) {
+                            serviceUrl = `https://${details.AccessInfo.PublicDomain}`;
                         }
-                        catch (error) {
-                            // Process doesn't exist, remove from tracking
-                            runningProcesses.delete(input.serverName);
+                        else {
+                            serviceUrl = ""; // URL not available
                         }
                     }
-                    const runPort = input.runOptions?.port ?? 3000;
-                    const extraEnv = input.runOptions?.envParams ?? {};
-                    // Set environment variables for functions-framework
-                    const env = {
-                        ...process.env,
-                        PORT: String(runPort),
-                        ...extraEnv,
-                        // Add functions-framework specific environment variables
-                        ENABLE_CORS: 'true',
-                        ALLOWED_ORIGINS: '*'
-                    };
-                    // Choose execution method based on run mode
-                    let child;
-                    let command;
-                    if (runMode === 'agent') {
-                        // For Agent mode, use a different approach since functions-framework doesn't support Agent mode
-                        // We'll use a custom script that sets up the Agent environment
-                        command = `node -e "
+                    catch (detailErr) {
+                        // If query fails, continue with empty URL
+                        serviceUrl = "";
+                    }
+                    // Extract project name from targetPath
+                    const projectName = path_1.default.basename(targetPath);
+                    // Build console URL
+                    const consoleUrl = `https://tcb.cloud.tencent.com/dev?envId=${currentEnvId}#/platform-run/service/detail?serverName=${input.serverName}&tabId=overview&envId=${currentEnvId}`;
+                    // Send notification
+                    await (0, notification_js_1.sendDeployNotification)(server, {
+                        deployType: 'cloudrun',
+                        url: serviceUrl,
+                        projectId: currentEnvId,
+                        projectName: projectName,
+                        consoleUrl: consoleUrl
+                    });
+                }
+                catch (notifyErr) {
+                    // Notification failure should not affect deployment flow
+                    // Error is already logged in sendDeployNotification
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    serviceName: input.serverName,
+                                    status: 'deployed',
+                                    deployPath: targetPath,
+                                    serverType: serverType,
+                                    cloudbasercGenerated: true
+                                },
+                                message: `Successfully deployed ${serverType} service '${input.serverName}' from ${targetPath}`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            case 'run': {
+                if (!targetPath) {
+                    throw new Error("targetPath is required for run operation");
+                }
+                // Do not support container services locally: basic heuristic - if Dockerfile exists, treat as container
+                const dockerfilePath = path_1.default.join(targetPath, 'Dockerfile');
+                if (fs_1.default.existsSync(dockerfilePath)) {
+                    throw new Error("Local run is only supported for function-type CloudRun services. Container services are not supported.");
+                }
+                // Check if this is an Agent project
+                const isAgent = checkIfAgentProject(targetPath);
+                const runMode = input.runOptions?.runMode || (isAgent ? 'agent' : 'normal');
+                // Check if service is already running and verify process exists
+                if (runningProcesses.has(input.serverName)) {
+                    const existingPid = runningProcesses.get(input.serverName);
+                    try {
+                        // Check if process actually exists
+                        process.kill(existingPid, 0);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        success: true,
+                                        data: {
+                                            serviceName: input.serverName,
+                                            status: 'running',
+                                            pid: existingPid,
+                                            cwd: targetPath
+                                        },
+                                        message: `Service '${input.serverName}' is already running locally (pid=${existingPid})`
+                                    }, null, 2)
+                                }
+                            ]
+                        };
+                    }
+                    catch (error) {
+                        // Process doesn't exist, remove from tracking
+                        runningProcesses.delete(input.serverName);
+                    }
+                }
+                const runPort = input.runOptions?.port ?? 3000;
+                const extraEnv = input.runOptions?.envParams ?? {};
+                // Set environment variables for functions-framework
+                const env = {
+                    ...process.env,
+                    PORT: String(runPort),
+                    ...extraEnv,
+                    // Add functions-framework specific environment variables
+                    ENABLE_CORS: 'true',
+                    ALLOWED_ORIGINS: '*'
+                };
+                // Choose execution method based on run mode
+                let child;
+                let command;
+                if (runMode === 'agent') {
+                    // For Agent mode, use a different approach since functions-framework doesn't support Agent mode
+                    // We'll use a custom script that sets up the Agent environment
+                    command = `node -e "
                 const { runCLI } = require('@cloudbase/functions-framework');
                 process.env.PORT = '${runPort}';
                 process.env.ENABLE_CORS = 'true';
@@ -8503,16 +8411,16 @@ for await (let x of res.textStream) {
                 ${Object.entries(extraEnv).map(([key, value]) => `process.env.${key} = '${value}';`).join('\n')}
                 runCLI();
               "`;
-                        child = (0, child_process_1.spawn)(process.execPath, ['-e', command], {
-                            cwd: targetPath,
-                            env,
-                            stdio: ['ignore', 'pipe', 'pipe'],
-                            detached: true
-                        });
-                    }
-                    else {
-                        // Normal function mode
-                        command = `node -e "
+                    child = (0, child_process_1.spawn)(process.execPath, ['-e', command], {
+                        cwd: targetPath,
+                        env,
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                        detached: true
+                    });
+                }
+                else {
+                    // Normal function mode
+                    command = `node -e "
                 const { runCLI } = require('@cloudbase/functions-framework');
                 process.env.PORT = '${runPort}';
                 process.env.ENABLE_CORS = 'true';
@@ -8520,182 +8428,167 @@ for await (let x of res.textStream) {
                 ${Object.entries(extraEnv).map(([key, value]) => `process.env.${key} = '${value}';`).join('\n')}
                 runCLI();
               "`;
-                        child = (0, child_process_1.spawn)(process.execPath, ['-e', command], {
-                            cwd: targetPath,
-                            env,
-                            stdio: ['ignore', 'pipe', 'pipe'],
-                            detached: true
-                        });
-                    }
-                    // Handle process exit to clean up tracking
-                    child.on('exit', (code, signal) => {
-                        runningProcesses.delete(input.serverName);
-                    });
-                    child.on('error', (error) => {
-                        runningProcesses.delete(input.serverName);
+                    child = (0, child_process_1.spawn)(process.execPath, ['-e', command], {
+                        cwd: targetPath,
+                        env,
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                        detached: true
                     });
-                    child.unref();
-                    if (typeof child.pid !== 'number') {
-                        throw new Error('Failed to start local process: PID is undefined.');
-                    }
-                    runningProcesses.set(input.serverName, child.pid);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        serviceName: input.serverName,
-                                        status: 'running',
-                                        pid: child.pid,
-                                        port: runPort,
-                                        runMode: runMode,
-                                        isAgent: isAgent,
-                                        command: command,
-                                        cwd: targetPath
-                                    },
-                                    message: `Started local run for ${runMode} service '${input.serverName}' on port ${runPort} (pid=${child.pid})`
-                                }, null, 2)
-                            }
-                        ]
-                    };
                 }
-                case 'download': {
-                    if (!targetPath) {
-                        throw new Error("targetPath is required for download operation");
-                    }
-                    const result = await cloudrunService.download({
-                        serverName: input.serverName,
-                        targetPath: targetPath,
-                    });
-                    // Generate cloudbaserc.json configuration file
-                    const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-                    const cloudbasercPath = path_1.default.join(targetPath, 'cloudbaserc.json');
-                    const cloudbasercContent = {
-                        envId: currentEnvId,
-                        cloudrun: {
-                            name: input.serverName
+                // Handle process exit to clean up tracking
+                child.on('exit', (code, signal) => {
+                    runningProcesses.delete(input.serverName);
+                });
+                child.on('error', (error) => {
+                    runningProcesses.delete(input.serverName);
+                });
+                child.unref();
+                if (typeof child.pid !== 'number') {
+                    throw new Error('Failed to start local process: PID is undefined.');
+                }
+                runningProcesses.set(input.serverName, child.pid);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    serviceName: input.serverName,
+                                    status: 'running',
+                                    pid: child.pid,
+                                    port: runPort,
+                                    runMode: runMode,
+                                    isAgent: isAgent,
+                                    command: command,
+                                    cwd: targetPath
+                                },
+                                message: `Started local run for ${runMode} service '${input.serverName}' on port ${runPort} (pid=${child.pid})`
+                            }, null, 2)
                         }
-                    };
-                    try {
-                        fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
-                    }
-                    catch (error) {
-                        // Ignore cloudbaserc.json creation errors
-                    }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        serviceName: input.serverName,
-                                        downloadPath: targetPath,
-                                        filesCount: 0,
-                                        cloudbasercGenerated: true
-                                    },
-                                    message: `Successfully downloaded service '${input.serverName}' to ${targetPath}`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+                    ]
+                };
+            }
+            case 'download': {
+                if (!targetPath) {
+                    throw new Error("targetPath is required for download operation");
                 }
-                case 'delete': {
-                    if (!input.force) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        success: false,
-                                        error: "Delete operation requires confirmation",
-                                        message: "Please set force: true to confirm deletion of the service. This action cannot be undone."
-                                    }, null, 2)
-                                }
-                            ]
-                        };
+                const result = await cloudrunService.download({
+                    serverName: input.serverName,
+                    targetPath: targetPath,
+                });
+                // Generate cloudbaserc.json configuration file
+                const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                const cloudbasercPath = path_1.default.join(targetPath, 'cloudbaserc.json');
+                const cloudbasercContent = {
+                    envId: currentEnvId,
+                    cloudrun: {
+                        name: input.serverName
                     }
-                    const result = await cloudrunService.delete({
-                        serverName: input.serverName,
-                    });
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        serviceName: input.serverName,
-                                        status: 'deleted'
-                                    },
-                                    message: `Successfully deleted service '${input.serverName}'`
-                                }, null, 2)
-                            }
-                        ]
-                    };
+                };
+                try {
+                    fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
                 }
-                case 'init': {
-                    if (!targetPath) {
-                        throw new Error("targetPath is required for init operation");
-                    }
-                    const result = await cloudrunService.init({
-                        serverName: input.serverName,
-                        targetPath: targetPath,
-                        template: input.template,
-                    });
-                    // Generate cloudbaserc.json configuration file
-                    const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-                    const cloudbasercPath = path_1.default.join(targetPath, input.serverName, 'cloudbaserc.json');
-                    const cloudbasercContent = {
-                        envId: currentEnvId,
-                        cloudrun: {
-                            name: input.serverName
+                catch (error) {
+                    // Ignore cloudbaserc.json creation errors
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    serviceName: input.serverName,
+                                    downloadPath: targetPath,
+                                    filesCount: 0,
+                                    cloudbasercGenerated: true
+                                },
+                                message: `Successfully downloaded service '${input.serverName}' to ${targetPath}`
+                            }, null, 2)
                         }
-                    };
-                    try {
-                        fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
-                    }
-                    catch (error) {
-                        // Ignore cloudbaserc.json creation errors
-                    }
+                    ]
+                };
+            }
+            case 'delete': {
+                if (!input.force) {
                     return {
                         content: [
                             {
                                 type: "text",
                                 text: JSON.stringify({
-                                    success: true,
-                                    data: {
-                                        serviceName: input.serverName,
-                                        template: input.template,
-                                        initPath: targetPath,
-                                        projectDir: result.projectDir || path_1.default.join(targetPath, input.serverName),
-                                        cloudbasercGenerated: true
-                                    },
-                                    message: `Successfully initialized service '${input.serverName}' with template '${input.template}' at ${targetPath}`
+                                    success: false,
+                                    error: "Delete operation requires confirmation",
+                                    message: "Please set force: true to confirm deletion of the service. This action cannot be undone."
                                 }, null, 2)
                             }
                         ]
                     };
                 }
-                default:
-                    throw new Error(`Unsupported action: ${input.action}`);
+                const result = await cloudrunService.delete({
+                    serverName: input.serverName,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    serviceName: input.serverName,
+                                    status: 'deleted'
+                                },
+                                message: `Successfully deleted service '${input.serverName}'`
+                            }, null, 2)
+                        }
+                    ]
+                };
             }
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message || 'Unknown error occurred',
-                            message: `Failed to ${args.action} CloudRun service. Please check your permissions and parameters.`
-                        }, null, 2)
+            case 'init': {
+                if (!targetPath) {
+                    throw new Error("targetPath is required for init operation");
+                }
+                const result = await cloudrunService.init({
+                    serverName: input.serverName,
+                    targetPath: targetPath,
+                    template: input.template,
+                });
+                // Generate cloudbaserc.json configuration file
+                const currentEnvId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+                const cloudbasercPath = path_1.default.join(targetPath, input.serverName, 'cloudbaserc.json');
+                const cloudbasercContent = {
+                    envId: currentEnvId,
+                    cloudrun: {
+                        name: input.serverName
                     }
-                ]
-            };
+                };
+                try {
+                    fs_1.default.writeFileSync(cloudbasercPath, JSON.stringify(cloudbasercContent, null, 2));
+                }
+                catch (error) {
+                    // Ignore cloudbaserc.json creation errors
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                data: {
+                                    serviceName: input.serverName,
+                                    template: input.template,
+                                    initPath: targetPath,
+                                    projectDir: result.projectDir || path_1.default.join(targetPath, input.serverName),
+                                    cloudbasercGenerated: true
+                                },
+                                message: `Successfully initialized service '${input.serverName}' with template '${input.template}' at ${targetPath}`
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            default:
+                throw new Error(`Unsupported action: ${input.action}`);
         }
     });
 }
@@ -8770,7 +8663,7 @@ class TelemetryReporter {
         const nodeVersion = process.version; // Node.js版本
         const arch = os_1.default.arch(); // 系统架构
         // 从构建时注入的版本号获取MCP版本信息
-        const mcpVersion = process.env.npm_package_version || "2.9.0" || 0;
+        const mcpVersion = process.env.npm_package_version || "2.11.0" || 0;
         return {
             userAgent: `${osType} ${osRelease} ${arch} ${nodeVersion} CloudBase-MCP/${mcpVersion}`,
             deviceId: this.deviceId,
@@ -10203,7 +10096,7 @@ function registerSetupTools(server) {
         title: "下载项目模板",
         description: `自动下载并部署CloudBase项目模板。⚠️ **MANDATORY FOR NEW PROJECTS** ⚠️
 
-**CRITICAL**: This tool MUST be called FIRST when starting a new project.\n\n支持的模板:\n- react: React + CloudBase 全栈应用模板\n- vue: Vue + CloudBase 全栈应用模板\n- miniprogram: 微信小程序 + 云开发模板  \n- uniapp: UniApp + CloudBase 跨端应用模板\n- rules: 只包含AI编辑器配置文件（包含Cursor、WindSurf、CodeBuddy等所有主流编辑器配置），适合在已有项目中补充AI编辑器配置\n\n支持的IDE类型:\n- all: 下载所有IDE配置\n- cursor: Cursor AI编辑器\n- 其他IDE类型见下方列表\n\n注意：如果未传入 ide 参数且无法从环境变量检测到 IDE，将提示错误并要求传入 ide 参数\n- windsurf: WindSurf AI编辑器\n- codebuddy: CodeBuddy AI编辑器\n- claude-code: Claude Code AI编辑器\n- cline: Cline AI编辑器\n- gemini-cli: Gemini CLI\n- opencode: OpenCode AI编辑器\n- qwen-code: 通义灵码\n- baidu-comate: 百度Comate\n- openai-codex-cli: OpenAI Codex CLI\n- augment-code: Augment Code\n- github-copilot: GitHub Copilot\n- roocode: RooCode AI编辑器\n- tongyi-lingma: 通义灵码\n- trae: Trae AI编辑器\n- qoder: Qoder AI编辑器\n- antigravity: Google Antigravity AI编辑器\n- vscode: Visual Studio Code\n- kiro: Kiro AI编辑器\n- aider: Aider AI编辑器\n\n特别说明：\n- rules 模板会自动包含当前 mcp 版本号信息（版本号：${ true ? "2.9.0" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
+**CRITICAL**: This tool MUST be called FIRST when starting a new project.\n\n支持的模板:\n- react: React + CloudBase 全栈应用模板\n- vue: Vue + CloudBase 全栈应用模板\n- miniprogram: 微信小程序 + 云开发模板  \n- uniapp: UniApp + CloudBase 跨端应用模板\n- rules: 只包含AI编辑器配置文件（包含Cursor、WindSurf、CodeBuddy等所有主流编辑器配置），适合在已有项目中补充AI编辑器配置\n\n支持的IDE类型:\n- all: 下载所有IDE配置\n- cursor: Cursor AI编辑器\n- 其他IDE类型见下方列表\n\n注意：如果未传入 ide 参数且无法从环境变量检测到 IDE，将提示错误并要求传入 ide 参数\n- windsurf: WindSurf AI编辑器\n- codebuddy: CodeBuddy AI编辑器\n- claude-code: Claude Code AI编辑器\n- cline: Cline AI编辑器\n- gemini-cli: Gemini CLI\n- opencode: OpenCode AI编辑器\n- qwen-code: 通义灵码\n- baidu-comate: 百度Comate\n- openai-codex-cli: OpenAI Codex CLI\n- augment-code: Augment Code\n- github-copilot: GitHub Copilot\n- roocode: RooCode AI编辑器\n- tongyi-lingma: 通义灵码\n- trae: Trae AI编辑器\n- qoder: Qoder AI编辑器\n- antigravity: Google Antigravity AI编辑器\n- vscode: Visual Studio Code\n- kiro: Kiro AI编辑器\n- aider: Aider AI编辑器\n\n特别说明：\n- rules 模板会自动包含当前 mcp 版本号信息（版本号：${ true ? "2.11.0" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
         inputSchema: {
             template: zod_1.z
                 .enum(["react", "vue", "miniprogram", "uniapp", "rules"])
@@ -12470,90 +12363,70 @@ function registerSecurityRuleTools(server) {
         },
     }, async ({ resourceType, resourceId }) => {
         const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-        try {
-            const cloudbase = await getManager();
-            let result;
-            if (resourceType === "noSqlDatabase") {
-                // 查询数据库安全规则
-                result = await cloudbase.commonService().call({
-                    Action: "DescribeSafeRule",
-                    Param: {
-                        CollectionName: resourceId,
-                        EnvId: envId,
-                    },
-                });
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            }
-            else if (resourceType === "function") {
-                // 查询云函数安全规则
-                result = await cloudbase.commonService().call({
-                    Action: "DescribeSecurityRule",
-                    Param: {
-                        ResourceType: "FUNCTION",
-                        EnvId: envId,
-                    },
-                });
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            }
-            else if (resourceType === "storage") {
-                // 查询存储安全规则
-                result = await cloudbase.commonService().call({
-                    Action: "DescribeStorageSafeRule",
-                    Param: {
-                        Bucket: resourceId,
-                        EnvId: envId,
-                    },
-                });
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            }
-            else if (resourceType === "sqlDatabase") {
-                // TODO: 考虑是否有支持指定其他 instance、schema 的需求
-                const instanceId = "default";
-                const schema = envId;
-                const tableName = resourceId;
-                result = await cloudbase.commonService("lowcode").call({
-                    Action: "DescribeDataSourceBasicPolicy",
-                    Param: {
-                        EnvId: envId,
-                        ResourceType: "table",
-                        ResourceId: `${instanceId}#${schema}#${tableName}`,
-                        RoleIdentityList: ["allUser"],
-                    },
-                });
-                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            }
-            else {
-                throw new Error(`不支持的资源类型: ${resourceType}`);
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            aclTag: result.AclTag,
-                            rule: result.Rule ?? null,
-                            raw: result,
-                            message: "安全规则读取成功",
-                        }, null, 2),
-                    },
-                ],
-            };
+        const cloudbase = await getManager();
+        let result;
+        if (resourceType === "noSqlDatabase") {
+            result = await cloudbase.commonService().call({
+                Action: "DescribeSafeRule",
+                Param: {
+                    CollectionName: resourceId,
+                    EnvId: envId,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
         }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message,
-                            message: "安全规则读取失败",
-                        }, null, 2),
-                    },
-                ],
-            };
+        else if (resourceType === "function") {
+            result = await cloudbase.commonService().call({
+                Action: "DescribeSecurityRule",
+                Param: {
+                    ResourceType: "FUNCTION",
+                    EnvId: envId,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        }
+        else if (resourceType === "storage") {
+            result = await cloudbase.commonService().call({
+                Action: "DescribeStorageSafeRule",
+                Param: {
+                    Bucket: resourceId,
+                    EnvId: envId,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        }
+        else if (resourceType === "sqlDatabase") {
+            const instanceId = "default";
+            const schema = envId;
+            const tableName = resourceId;
+            result = await cloudbase.commonService("lowcode").call({
+                Action: "DescribeDataSourceBasicPolicy",
+                Param: {
+                    EnvId: envId,
+                    ResourceType: "table",
+                    ResourceId: `${instanceId}#${schema}#${tableName}`,
+                    RoleIdentityList: ["allUser"],
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        }
+        else {
+            throw new Error(`不支持的资源类型: ${resourceType}`);
         }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        aclTag: result.AclTag,
+                        rule: result.Rule ?? null,
+                        raw: result,
+                        message: "安全规则读取成功",
+                    }, null, 2),
+                },
+            ],
+        };
     });
     // 写入安全规则 Tool
     server.registerTool?.(exports.WRITE_SECURITY_RULE, {
@@ -12580,154 +12453,138 @@ function registerSecurityRuleTools(server) {
             category: "security-rule",
         },
     }, async ({ resourceType, resourceId, aclTag, rule }) => {
-        try {
-            const cloudbase = await getManager();
-            const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            let result;
-            if (resourceType === "noSqlDatabase") {
-                if (aclTag === "CUSTOM") {
-                    if (!rule)
-                        throw new Error("noSQL 数据库自定义安全规则（CUSTOM）必须提供 rule 字段");
-                    result = await cloudbase.commonService().call({
-                        Action: "ModifySafeRule",
-                        Param: {
-                            CollectionName: resourceId,
-                            EnvId: envId,
-                            AclTag: aclTag,
-                            Rule: rule,
-                        },
-                    });
-                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                }
-                else {
-                    result = await cloudbase.commonService().call({
-                        Action: "ModifyDatabaseACL",
-                        Param: {
-                            CollectionName: resourceId,
-                            EnvId: envId,
-                            AclTag: aclTag,
-                        },
-                    });
-                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                }
-            }
-            else if (resourceType === "function") {
-                if (aclTag !== "CUSTOM")
-                    throw new Error("云函数安全规则仅支持 CUSTOM 权限类别");
+        const cloudbase = await getManager();
+        const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        let result;
+        if (resourceType === "noSqlDatabase") {
+            if (aclTag === "CUSTOM") {
                 if (!rule)
-                    throw new Error("云函数自定义安全规则（CUSTOM）必须提供 rule 字段");
+                    throw new Error("noSQL 数据库自定义安全规则（CUSTOM）必须提供 rule 字段");
                 result = await cloudbase.commonService().call({
-                    Action: "ModifySecurityRule",
+                    Action: "ModifySafeRule",
                     Param: {
-                        AclTag: aclTag,
+                        CollectionName: resourceId,
                         EnvId: envId,
-                        ResourceType: "FUNCTION",
+                        AclTag: aclTag,
                         Rule: rule,
                     },
                 });
                 (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
             }
-            else if (resourceType === "storage") {
-                if (aclTag === "CUSTOM") {
-                    if (!rule)
-                        throw new Error("存储自定义安全规则（CUSTOM）必须提供 rule 字段");
-                    result = await cloudbase.commonService().call({
-                        Action: "ModifyStorageSafeRule",
-                        Param: {
-                            Bucket: resourceId,
-                            EnvId: envId,
-                            AclTag: aclTag,
-                            Rule: rule,
-                        },
-                    });
-                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                }
-                else {
-                    result = await cloudbase.commonService().call({
-                        Action: "ModifyStorageSafeRule",
-                        Param: {
-                            Bucket: resourceId,
-                            EnvId: envId,
-                            AclTag: aclTag,
-                        },
-                    });
-                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                }
+            else {
+                result = await cloudbase.commonService().call({
+                    Action: "ModifyDatabaseACL",
+                    Param: {
+                        CollectionName: resourceId,
+                        EnvId: envId,
+                        AclTag: aclTag,
+                    },
+                });
+                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
             }
-            else if (resourceType === "sqlDatabase") {
-                if (aclTag === "CUSTOM") {
-                    throw new Error("SQL 数据库不支持自定义安全规则（CUSTOM）");
-                }
-                const schema = envId;
-                const tableName = resourceId;
-                const instanceId = "default";
-                const resource = `${instanceId}#${schema}#${tableName}`;
-                const resourceType = "table";
-                const effect = "allow";
-                const policyList = [
-                    "allUser",
-                    "anonymousUser",
-                    "externalUser",
-                    "internalUser",
-                ].map((roleIdentity) => ({
-                    RoleIdentity: roleIdentity,
-                    ResourceType: resourceType,
-                    ResourceId: resource,
-                    RowPermission: [],
-                    Effect: effect,
-                }));
-                policyList[0].RowPermission = getRowPermission(aclTag);
-                result = await cloudbase.commonService("lowcode").call({
-                    Action: "BatchCreateResourcePolicy",
+        }
+        else if (resourceType === "function") {
+            if (aclTag !== "CUSTOM")
+                throw new Error("云函数安全规则仅支持 CUSTOM 权限类别");
+            if (!rule)
+                throw new Error("云函数自定义安全规则（CUSTOM）必须提供 rule 字段");
+            result = await cloudbase.commonService().call({
+                Action: "ModifySecurityRule",
+                Param: {
+                    AclTag: aclTag,
+                    EnvId: envId,
+                    ResourceType: "FUNCTION",
+                    Rule: rule,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        }
+        else if (resourceType === "storage") {
+            if (aclTag === "CUSTOM") {
+                if (!rule)
+                    throw new Error("存储自定义安全规则（CUSTOM）必须提供 rule 字段");
+                result = await cloudbase.commonService().call({
+                    Action: "ModifyStorageSafeRule",
                     Param: {
+                        Bucket: resourceId,
                         EnvId: envId,
-                        PolicyList: policyList,
+                        AclTag: aclTag,
+                        Rule: rule,
                     },
                 });
                 (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-                function getRowPermission(policy) {
-                    return {
-                        READONLY: [
-                            { Key: "all", Value: "r" },
-                            { Key: "me", Value: "rw" },
-                        ],
-                        PRIVATE: [{ Key: "me", Value: "rw" }],
-                        ADMINWRITE: [{ Key: "all", Value: "r" }],
-                        ADMINONLY: [],
-                    }[policy];
-                }
             }
             else {
-                throw new Error(`不支持的资源类型: ${resourceType}`);
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            requestId: result.RequestId,
-                            raw: result,
-                            message: "安全规则写入成功",
-                        }, null, 2),
+                result = await cloudbase.commonService().call({
+                    Action: "ModifyStorageSafeRule",
+                    Param: {
+                        Bucket: resourceId,
+                        EnvId: envId,
+                        AclTag: aclTag,
                     },
-                ],
-            };
+                });
+                (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+            }
         }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message,
-                            message: "安全规则写入失败",
-                        }, null, 2),
-                    },
-                ],
-            };
+        else if (resourceType === "sqlDatabase") {
+            if (aclTag === "CUSTOM") {
+                throw new Error("SQL 数据库不支持自定义安全规则（CUSTOM）");
+            }
+            const schema = envId;
+            const tableName = resourceId;
+            const instanceId = "default";
+            const resource = `${instanceId}#${schema}#${tableName}`;
+            const resourceType = "table";
+            const effect = "allow";
+            const policyList = [
+                "allUser",
+                "anonymousUser",
+                "externalUser",
+                "internalUser",
+            ].map((roleIdentity) => ({
+                RoleIdentity: roleIdentity,
+                ResourceType: resourceType,
+                ResourceId: resource,
+                RowPermission: [],
+                Effect: effect,
+            }));
+            policyList[0].RowPermission = getRowPermission(aclTag);
+            result = await cloudbase.commonService("lowcode").call({
+                Action: "BatchCreateResourcePolicy",
+                Param: {
+                    EnvId: envId,
+                    PolicyList: policyList,
+                },
+            });
+            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+            function getRowPermission(policy) {
+                return {
+                    READONLY: [
+                        { Key: "all", Value: "r" },
+                        { Key: "me", Value: "rw" },
+                    ],
+                    PRIVATE: [{ Key: "me", Value: "rw" }],
+                    ADMINWRITE: [{ Key: "all", Value: "r" }],
+                    ADMINONLY: [],
+                }[policy];
+            }
+        }
+        else {
+            throw new Error(`不支持的资源类型: ${resourceType}`);
         }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        requestId: result.RequestId,
+                        raw: result,
+                        message: "安全规则写入成功",
+                    }, null, 2),
+                },
+            ],
+        };
     });
 }
 
@@ -13410,64 +13267,44 @@ function registerDownloadTools(server) {
             category: "download"
         }
     }, async ({ url, relativePath }) => {
-        try {
-            // 验证相对路径安全性
-            if (!isPathSafe(relativePath)) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: false,
-                                error: "不安全的相对路径",
-                                message: "相对路径包含路径遍历操作（../）或绝对路径，出于安全考虑已拒绝",
-                                suggestion: "请使用项目根目录下的相对路径，例如：'assets/images/logo.png'"
-                            }, null, 2)
-                        }
-                    ]
-                };
-            }
-            // 计算最终下载路径
-            const targetPath = calculateDownloadPath(relativePath);
-            const projectRoot = getProjectRoot();
-            console.log(`📁 项目根目录: ${projectRoot}`);
-            console.log(`📁 相对路径: ${relativePath}`);
-            console.log(`📁 最终路径: ${targetPath}`);
-            // 下载文件到指定路径
-            const result = await downloadFileToPath(url, targetPath);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            filePath: result.filePath,
-                            relativePath: relativePath,
-                            contentType: result.contentType,
-                            fileSize: result.fileSize,
-                            projectRoot: projectRoot,
-                            message: "文件下载成功到指定路径",
-                            note: `文件已保存到项目目录: ${relativePath}`
-                        }, null, 2)
-                    }
-                ]
-            };
-        }
-        catch (error) {
+        if (!isPathSafe(relativePath)) {
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
                             success: false,
-                            error: error.message,
-                            message: "文件下载失败",
-                            suggestion: "请检查相对路径是否正确，确保不包含 ../ 等路径遍历操作"
+                            error: "不安全的相对路径",
+                            message: "相对路径包含路径遍历操作（../）或绝对路径，出于安全考虑已拒绝",
+                            suggestion: "请使用项目根目录下的相对路径，例如：'assets/images/logo.png'"
                         }, null, 2)
                     }
                 ]
             };
         }
+        const targetPath = calculateDownloadPath(relativePath);
+        const projectRoot = getProjectRoot();
+        console.log(`📁 项目根目录: ${projectRoot}`);
+        console.log(`📁 相对路径: ${relativePath}`);
+        console.log(`📁 最终路径: ${targetPath}`);
+        const result = await downloadFileToPath(url, targetPath);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        filePath: result.filePath,
+                        relativePath: relativePath,
+                        contentType: result.contentType,
+                        fileSize: result.fileSize,
+                        projectRoot: projectRoot,
+                        message: "文件下载成功到指定路径",
+                        note: `文件已保存到项目目录: ${relativePath}`
+                    }, null, 2)
+                }
+            ]
+        };
     });
 }
 
@@ -13682,52 +13519,35 @@ function registerSQLDatabaseTools(server) {
             category: CATEGORY,
         },
     }, async ({ sql }) => {
-        try {
-            const cloudbase = await getManager();
-            const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            // TODO: 考虑是否有支持指定其他 instance、schema 的需求
-            const schemaId = envId;
-            const instanceId = "default";
-            const result = await cloudbase.commonService("tcb", "2018-06-08").call({
-                Action: "RunSql",
-                Param: {
+        const cloudbase = await getManager();
+        const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        const schemaId = envId;
+        const instanceId = "default";
+        const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+            Action: "RunSql",
+            Param: {
+                EnvId: envId,
+                Sql: sql,
+                DbInstance: {
                     EnvId: envId,
-                    Sql: sql,
-                    DbInstance: {
-                        EnvId: envId,
-                        InstanceId: instanceId,
-                        Schema: schemaId,
-                    },
+                    InstanceId: instanceId,
+                    Schema: schemaId,
                 },
-            });
-            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            message: "SQL query executed successfully",
-                            result,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message,
-                            message: "SQL query execution failed",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
+            },
+        });
+        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        message: "SQL query executed successfully",
+                        result,
+                    }, null, 2),
+                },
+            ],
+        };
     });
     // executeWriteSQL
     server.registerTool?.("executeWriteSQL", {
@@ -13746,52 +13566,35 @@ function registerSQLDatabaseTools(server) {
             category: CATEGORY,
         },
     }, async ({ sql }) => {
-        try {
-            const cloudbase = await getManager();
-            const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
-            // TODO: 考虑是否有支持指定其他 instance、schema 的需求
-            const schemaId = envId;
-            const instanceId = "default";
-            const result = await cloudbase.commonService("tcb", "2018-06-08").call({
-                Action: "RunSql",
-                Param: {
+        const cloudbase = await getManager();
+        const envId = await (0, cloudbase_manager_js_1.getEnvId)(cloudBaseOptions);
+        const schemaId = envId;
+        const instanceId = "default";
+        const result = await cloudbase.commonService("tcb", "2018-06-08").call({
+            Action: "RunSql",
+            Param: {
+                EnvId: envId,
+                Sql: sql,
+                DbInstance: {
                     EnvId: envId,
-                    Sql: sql,
-                    DbInstance: {
-                        EnvId: envId,
-                        InstanceId: instanceId,
-                        Schema: schemaId,
-                    },
+                    InstanceId: instanceId,
+                    Schema: schemaId,
                 },
-            });
-            (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            message: `SQL statement executed successfully. If you just created a table, make sure to check its security rule is set to a proper value by using \`${security_rule_js_1.WRITE_SECURITY_RULE}\` and \`${security_rule_js_1.READ_SECURITY_RULE}\` tools.`,
-                            result,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message,
-                            message: "SQL statement execution failed",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
+            },
+        });
+        (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, result);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        message: `SQL statement executed successfully. If you just created a table, make sure to check its security rule is set to a proper value by using \`${security_rule_js_1.WRITE_SECURITY_RULE}\` and \`${security_rule_js_1.READ_SECURITY_RULE}\` tools.`,
+                        result,
+                    }, null, 2),
+                },
+            ],
+        };
     });
 }