@cloudbase/cloudbase-mcp 1.7.0 → 1.7.2

package/dist/tools/env.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { getCloudBaseManager } from '../cloudbase-manager.js';
 import { logout } from '../auth.js';
 import { clearUserEnvId, _promptAndSetEnvironmentId } from './interactive.js';
+import { debug } from '../utils/logger.js';
 export function registerEnvTools(server) {
     // login - 登录云开发环境
     server.tool("login", "登录云开发环境并选择要使用的环境", {
@@ -9,6 +10,7 @@ export function registerEnvTools(server) {
     }, async ({ forceUpdate = false }) => {
         try {
             const { selectedEnvId, cancelled, error, noEnvs } = await _promptAndSetEnvironmentId(false);
+            debug("login", { selectedEnvId, cancelled, error, noEnvs });
             if (error) {
                 return { content: [{ type: "text", text: error }] };
             }

package/dist/tools/functions.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { getCloudBaseManager } from '../cloudbase-manager.js';
+import path from 'path';
 // 支持的 Node.js 运行时列表
 export const SUPPORTED_NODEJS_RUNTIMES = [
     'Nodejs 18.15',
@@ -10,6 +11,25 @@ export const SUPPORTED_NODEJS_RUNTIMES = [
     'Nodejs 8.9（即将下线）',
 ];
 export const DEFAULT_NODEJS_RUNTIME = 'Nodejs 18.15';
+/**
+ * 处理函数根目录路径，确保不包含函数名
+ * @param functionRootPath 用户输入的路径
+ * @param functionName 函数名称
+ * @returns 处理后的根目录路径
+ */
+function processFunctionRootPath(functionRootPath, functionName) {
+    if (!functionRootPath)
+        return functionRootPath;
+    const normalizedPath = path.normalize(functionRootPath);
+    const lastDir = path.basename(normalizedPath);
+    // 如果路径的最后一级目录名与函数名相同，说明用户可能传入了包含函数名的路径
+    if (lastDir === functionName) {
+        const parentPath = path.dirname(normalizedPath);
+        console.warn(`检测到 functionRootPath 包含函数名 "${functionName}"，已自动调整为父目录: ${parentPath}`);
+        return parentPath;
+    }
+    return functionRootPath;
+}
 export function registerFunctionTools(server) {
     // getFunctionList - 获取云函数列表(推荐)
     server.tool("getFunctionList", "获取云函数列表", {
@@ -52,17 +72,19 @@ export function registerFunctionTools(server) {
                 version: z.number()
             })).optional().describe("Layer配置")
         }).describe("函数配置"),
-        functionRootPath: z.string().optional().describe("函数根目录（云函数目录的父目录），这里需要传操作系统上文件的绝对路径，指定之后可以自动上传这部分的文件作为代码"),
+        functionRootPath: z.string().optional().describe("函数根目录（云函数目录的父目录），这里需要传操作系统上文件的绝对路径，注意：不要包含函数名本身，例如函数名为 'hello'，应传入 '/path/to/cloudfunctions'，而不是 '/path/to/cloudfunctions/hello'"),
         force: z.boolean().describe("是否覆盖")
     }, async ({ func, functionRootPath, force }) => {
         // 自动填充默认 runtime
         if (!func.runtime) {
             func.runtime = DEFAULT_NODEJS_RUNTIME;
         }
+        // 处理函数根目录路径，确保不包含函数名
+        const processedRootPath = processFunctionRootPath(functionRootPath, func.name);
         const cloudbase = await getCloudBaseManager();
         const result = await cloudbase.functions.createFunction({
             func,
-            functionRootPath,
+            functionRootPath: processedRootPath,
             force
         });
         return {
@@ -79,15 +101,17 @@ export function registerFunctionTools(server) {
         func: z.object({
             name: z.string().describe("函数名称")
         }).describe("函数配置"),
-        functionRootPath: z.string().optional().describe("函数根目录（云函数目录的父目录），这里需要传操作系统上文件的绝对路径，指定之后可以自动上传这部分的文件作为代码")
+        functionRootPath: z.string().optional().describe("函数根目录（云函数目录的父目录），这里需要传操作系统上文件的绝对路径，注意：不要包含函数名本身，例如函数名为 'hello'，应传入 '/path/to/cloudfunctions'，而不是 '/path/to/cloudfunctions/hello'")
     }, async ({ func, functionRootPath }) => {
+        // 处理函数根目录路径，确保不包含函数名
+        const processedRootPath = processFunctionRootPath(functionRootPath, func.name);
         const cloudbase = await getCloudBaseManager();
         const result = await cloudbase.functions.updateFunctionCode({
             func: {
                 ...func,
                 installDependency: true // 默认安装依赖
             },
-            functionRootPath,
+            functionRootPath: processedRootPath,
         });
         return {
             content: [

package/dist/tools/hosting.js

@@ -96,109 +96,16 @@ export function registerHostingTools(server) {
             ]
         };
     });
-    // // setWebsiteDocument - 配置静态网站文档
-    // server.tool(
-    //   "setWebsiteDocument",
-    //   "配置静态网站的错误文档、索引文档和重定向规则",
-    //   {
-    //     indexDocument: z.string().describe("索引文档路径"),
-    //     errorDocument: z.string().optional().describe("错误文档路径"),
-    //     routingRules: z.array(z.object({
-    //       keyPrefixEquals: z.string().optional(),
-    //       httpErrorCodeReturnedEquals: z.string().optional(),
-    //       replaceKeyWith: z.string().optional(),
-    //       replaceKeyPrefixWith: z.string().optional()
-    //     })).optional().describe("重定向规则")
-    //   },
-    //   async ({ indexDocument, errorDocument, routingRules }) => {
-    //     const cloudbase = await getCloudBaseManager()
-    //     const result = await cloudbase.hosting.setWebsiteDocument({
-    //       indexDocument,
-    //       errorDocument,
-    //       routingRules
-    //     });
-    //     return {
-    //       content: [
-    //         {
-    //           type: "text",
-    //           text: JSON.stringify(result, null, 2)
-    //         }
-    //       ]
-    //     };
-    //   }
-    // );
-    // createHostingDomain - 绑定自定义域名
-    server.tool("createHostingDomain", "绑定自定义域名", {
-        domain: z.string().describe("自定义域名"),
-        certId: z.string().describe("证书ID")
-    }, async ({ domain, certId }) => {
-        const cloudbase = await getCloudBaseManager();
-        const result = await cloudbase.hosting.CreateHostingDomain({
-            domain,
-            certId
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(result, null, 2)
-                }
-            ]
-        };
-    });
-    // deleteHostingDomain - 解绑自定义域名
-    server.tool("deleteHostingDomain", "解绑自定义域名", {
-        domain: z.string().describe("自定义域名")
-    }, async ({ domain }) => {
-        const cloudbase = await getCloudBaseManager();
-        const result = await cloudbase.hosting.deleteHostingDomain({
-            domain
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(result, null, 2)
-                }
-            ]
-        };
-    });
-    // getWebsiteConfig - 获取静态网站配置
-    server.tool("getWebsiteConfig", "获取静态网站配置", {
-        confirm: z.literal("yes").describe("确认操作，默认传 yes")
-    }, async () => {
-        const cloudbase = await getCloudBaseManager();
-        const result = await cloudbase.hosting.getWebsiteConfig();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(result, null, 2)
-                }
-            ]
-        };
-    });
-    // tcbCheckResource - 获取域名配置
-    server.tool("tcbCheckResource", "获取域名配置", {
-        domains: z.array(z.string()).describe("域名列表")
-    }, async ({ domains }) => {
-        const cloudbase = await getCloudBaseManager();
-        const result = await cloudbase.hosting.tcbCheckResource({
-            domains
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(result, null, 2)
-                }
-            ]
-        };
-    });
-    // tcbModifyAttribute - 修改域名配置
-    server.tool("tcbModifyAttribute", "修改域名配置", {
-        domain: z.string().describe("域名"),
-        domainId: z.number().describe("域名ID"),
+    // domainManagement - 统一的域名管理工具
+    server.tool("domainManagement", "统一的域名管理工具，支持绑定、解绑、查询和修改域名配置", {
+        action: z.enum(["create", "delete", "check", "modify"]).describe("操作类型: create=绑定域名, delete=解绑域名, check=查询域名配置, modify=修改域名配置"),
+        // 绑定域名参数
+        domain: z.string().optional().describe("域名"),
+        certId: z.string().optional().describe("证书ID（绑定域名时必需）"),
+        // 查询域名参数
+        domains: z.array(z.string()).optional().describe("域名列表（查询配置时使用）"),
+        // 修改域名参数
+        domainId: z.number().optional().describe("域名ID（修改配置时必需）"),
         domainConfig: z.object({
             Refer: z.object({
                 Switch: z.string(),
@@ -222,14 +129,67 @@ export function registerHostingTools(server) {
                 Switch: z.string(),
                 Qps: z.number().optional()
             }).optional()
-        }).describe("域名配置")
-    }, async ({ domain, domainId, domainConfig }) => {
+        }).optional().describe("域名配置（修改配置时使用）")
+    }, async ({ action, domain, certId, domains, domainId, domainConfig }) => {
         const cloudbase = await getCloudBaseManager();
-        const result = await cloudbase.hosting.tcbModifyAttribute({
-            domain,
-            domainId,
-            domainConfig
-        });
+        let result;
+        switch (action) {
+            case "create":
+                if (!domain || !certId) {
+                    throw new Error("绑定域名需要提供域名和证书ID");
+                }
+                result = await cloudbase.hosting.CreateHostingDomain({
+                    domain,
+                    certId
+                });
+                break;
+            case "delete":
+                if (!domain) {
+                    throw new Error("解绑域名需要提供域名");
+                }
+                result = await cloudbase.hosting.deleteHostingDomain({
+                    domain
+                });
+                break;
+            case "check":
+                if (!domains || domains.length === 0) {
+                    throw new Error("查询域名配置需要提供域名列表");
+                }
+                result = await cloudbase.hosting.tcbCheckResource({
+                    domains
+                });
+                break;
+            case "modify":
+                if (!domain || domainId === undefined || !domainConfig) {
+                    throw new Error("修改域名配置需要提供域名、域名ID和配置信息");
+                }
+                result = await cloudbase.hosting.tcbModifyAttribute({
+                    domain,
+                    domainId,
+                    domainConfig
+                });
+                break;
+            default:
+                throw new Error(`不支持的操作类型: ${action}`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        action,
+                        result
+                    }, null, 2)
+                }
+            ]
+        };
+    });
+    // getWebsiteConfig - 获取静态网站配置
+    server.tool("getWebsiteConfig", "获取静态网站配置", {
+        confirm: z.literal("yes").describe("确认操作，默认传 yes")
+    }, async () => {
+        const cloudbase = await getCloudBaseManager();
+        const result = await cloudbase.hosting.getWebsiteConfig();
         return {
             content: [
                 {

package/dist/tools/interactive.js

@@ -29,7 +29,7 @@ export function registerInteractiveTools(server) {
                     return {
                         content: [{
                                 type: "text",
-                                text: `📝 用户澄清反馈:\n${result.data.response}`
+                                text: `📝 用户澄清反馈:\n${result.data}`
                             }]
                     };
                 }
@@ -45,13 +45,13 @@ export function registerInteractiveTools(server) {
                     const dialogOptions = options || ["确认执行", "取消操作", "需要修改任务"];
                     const interactiveServer = getInteractiveServer();
                     const result = await interactiveServer.clarifyRequest(dialogMessage, dialogOptions);
-                    if (result.cancelled || result.data.response.includes('取消')) {
+                    if (result.cancelled || (result.data && result.data.includes && result.data.includes('取消'))) {
                         return { content: [{ type: "text", text: "❌ 用户取消了任务执行" }] };
                     }
                     return {
                         content: [{
                                 type: "text",
-                                text: `✅ 用户确认: ${result.data.response}`
+                                text: `✅ 用户确认: ${result.data}`
                             }]
                     };
                 }
@@ -95,7 +95,7 @@ export async function _promptAndSetEnvironmentId(autoSelectSingle) {
         if (result.cancelled) {
             return { selectedEnvId: null, cancelled: true };
         }
-        selectedEnvId = result.data.envId;
+        selectedEnvId = result.data;
     }
     // 4. 保存并设置环境ID
     if (selectedEnvId) {

package/dist/tools/setup.js

@@ -97,6 +97,27 @@ async function copyFileIfNotExists(src, dest) {
         return { copied: false, reason: `复制失败: ${error instanceof Error ? error.message : '未知错误'}` };
     }
 }
+// 复制文件，支持覆盖模式
+async function copyFile(src, dest, overwrite = false) {
+    try {
+        const destExists = fs.existsSync(dest);
+        // 如果目标文件存在且不允许覆盖
+        if (destExists && !overwrite) {
+            return { copied: false, reason: '文件已存在', action: 'skipped' };
+        }
+        // 创建目标目录
+        await fsPromises.mkdir(path.dirname(dest), { recursive: true });
+        // 复制文件
+        await fsPromises.copyFile(src, dest);
+        return {
+            copied: true,
+            action: destExists ? 'overwritten' : 'created'
+        };
+    }
+    catch (error) {
+        return { copied: false, reason: `复制失败: ${error instanceof Error ? error.message : '未知错误'}` };
+    }
+}
 export function registerSetupTools(server) {
     server.tool("downloadTemplate", `自动下载并部署CloudBase项目模板。
 
@@ -105,9 +126,10 @@ export function registerSetupTools(server) {
 - miniprogram: 微信小程序 + 云开发模板  
 - rules: 只包含AI编辑器配置文件（包含Cursor、WindSurf、CodeBuddy等所有主流编辑器配置），适合在已有项目中补充AI编辑器配置
 
-工具会自动下载模板到临时目录，解压后如果检测到WORKSPACE_FOLDER_PATHS环境变量，则复制到项目目录（不覆盖已存在文件）。`, {
-        template: z.enum(["react", "miniprogram", "rules"]).describe("要下载的模板类型")
-    }, async ({ template }) => {
+工具会自动下载模板到临时目录，解压后如果检测到WORKSPACE_FOLDER_PATHS环境变量，则复制到项目目录。`, {
+        template: z.enum(["react", "miniprogram", "rules"]).describe("要下载的模板类型"),
+        overwrite: z.boolean().optional().describe("是否覆盖已存在的文件，默认为false（不覆盖）")
+    }, async ({ template, overwrite = false }) => {
         try {
             const templateConfig = TEMPLATES[template];
             if (!templateConfig) {
@@ -131,16 +153,22 @@ export function registerSetupTools(server) {
             // 检查是否需要复制到项目目录
             const workspaceFolder = process.env.WORKSPACE_FOLDER_PATHS;
             let finalFiles = [];
-            let copiedCount = 0;
+            let createdCount = 0;
+            let overwrittenCount = 0;
             let skippedCount = 0;
             const results = [];
             if (workspaceFolder) {
                 for (const relativePath of extractedFiles) {
                     const srcPath = path.join(extractDir, relativePath);
                     const destPath = path.join(workspaceFolder, relativePath);
-                    const copyResult = await copyFileIfNotExists(srcPath, destPath);
+                    const copyResult = await copyFile(srcPath, destPath, overwrite);
                     if (copyResult.copied) {
-                        copiedCount++;
+                        if (copyResult.action === 'overwritten') {
+                            overwrittenCount++;
+                        }
+                        else {
+                            createdCount++;
+                        }
                         finalFiles.push(destPath);
                     }
                     else {
@@ -149,8 +177,20 @@ export function registerSetupTools(server) {
                     }
                 }
                 results.push(`✅ ${templateConfig.description} 同步完成`);
-                results.push(`📁 保存在临时目录: ${extractDir}`);
-                results.push(`📊 复制了 ${copiedCount} 个文件${skippedCount > 0 ? `，跳过 ${skippedCount} 个已存在文件` : ''}`);
+                results.push(`📁 临时目录: ${extractDir}`);
+                const stats = [];
+                if (createdCount > 0)
+                    stats.push(`新建 ${createdCount} 个文件`);
+                if (overwrittenCount > 0)
+                    stats.push(`覆盖 ${overwrittenCount} 个文件`);
+                if (skippedCount > 0)
+                    stats.push(`跳过 ${skippedCount} 个已存在文件`);
+                if (stats.length > 0) {
+                    results.push(`📊 ${stats.join('，')}`);
+                }
+                if (overwrite || overwrittenCount > 0 || skippedCount > 0) {
+                    results.push(`🔄 覆盖模式: ${overwrite ? '启用' : '禁用'}`);
+                }
             }
             else {
                 finalFiles = extractedFiles.map(relativePath => path.join(extractDir, relativePath));

package/dist/utils/logger.js

@@ -14,8 +14,8 @@ class Logger {
     logFile;
     useConsole;
     constructor(options = {}) {
-        // 通过环境变量控制是否启用日志
-        this.enabled = options.enabled ?? (process.env.MCP_DEBUG === 'true' || process.env.NODE_ENV === 'development');
+        // 默认开启
+        this.enabled = options.enabled ?? true;
         this.level = options.level ?? LogLevel.INFO;
         this.useConsole = options.console ?? false;
         // 默认日志文件路径

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudbase/cloudbase-mcp",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "腾讯云开发 MCP Server，支持静态托管/环境查询/",
   "main": "index.js",
   "type": "module",