@cloudbase/cloudbase-mcp 1.6.0 → 1.7.1

package/dist/tools/env.js

@@ -1,26 +1,74 @@
 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) {
-    // logout
-    server.tool("logout", "登出当前云开发账户", {
+    // login - 登录云开发环境
+    server.tool("login", "登录云开发环境并选择要使用的环境", {
+        forceUpdate: z.boolean().optional().describe("是否强制重新选择环境")
+    }, 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 }] };
+            }
+            if (noEnvs) {
+                return { content: [{ type: "text", text: "当前账户下暂无可用的云开发环境，请先在腾讯云控制台创建环境" }] };
+            }
+            if (cancelled) {
+                return { content: [{ type: "text", text: "用户取消了登录" }] };
+            }
+            if (selectedEnvId) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `✅ 登录成功，当前环境: ${selectedEnvId}`
+                        }]
+                };
+            }
+            throw new Error("登录失败");
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `登录失败: ${error instanceof Error ? error.message : String(error)}`
+                    }]
+            };
+        }
+    });
+    // logout - 退出云开发环境
+    server.tool("logout", "退出云开发环境", {
         confirm: z.literal("yes").describe("确认操作，默认传 yes")
-    }, async ({ confirm }) => {
-        const result = await logout();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "success"
-                }
-            ]
-        };
+    }, async () => {
+        try {
+            // 登出账户
+            await logout();
+            // 清理环境ID配置
+            await clearUserEnvId();
+            return {
+                content: [{
+                        type: "text",
+                        text: "✅ 已退出登录"
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `退出失败: ${error instanceof Error ? error.message : String(error)}`
+                    }]
+            };
+        }
     });
     // listEnvs
     server.tool("listEnvs", "获取所有云开发环境信息", {
         confirm: z.literal("yes").describe("确认操作，默认传 yes")
     }, async () => {
-        const cloudbase = await getCloudBaseManager();
+        const cloudbase = await getCloudBaseManager({ requireEnvId: false });
         const result = await cloudbase.env.listEnvs();
         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

@@ -0,0 +1,198 @@
+import { z } from "zod";
+import { getInteractiveServer } from "../interactive-server.js";
+import { getCloudBaseManager } from '../cloudbase-manager.js';
+import { getLoginState } from '../auth.js';
+import { debug, warn } from '../utils/logger.js';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+export function registerInteractiveTools(server) {
+    // 统一的交互式对话工具
+    server.tool("interactiveDialog", "统一的交互式对话工具，支持需求澄清和任务确认，当需要和用户确认下一步的操作的时候，可以调用这个工具的clarify，如果有敏感的操作，需要用户确认，可以调用这个工具的confirm", {
+        type: z.enum(['clarify', 'confirm']).describe("交互类型: clarify=需求澄清, confirm=任务确认"),
+        message: z.string().optional().describe("对话消息内容"),
+        options: z.array(z.string()).optional().describe("可选的预设选项"),
+        forceUpdate: z.boolean().optional().describe("是否强制更新环境ID配置"),
+        risks: z.array(z.string()).optional().describe("操作风险提示")
+    }, async ({ type, message, options, forceUpdate = false, risks }) => {
+        try {
+            switch (type) {
+                case 'clarify': {
+                    if (!message) {
+                        throw new Error("需求澄清必须提供message参数");
+                    }
+                    const interactiveServer = getInteractiveServer();
+                    const result = await interactiveServer.clarifyRequest(message, options);
+                    if (result.cancelled) {
+                        return { content: [{ type: "text", text: "用户取消了需求澄清" }] };
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `📝 用户澄清反馈:\n${result.data}`
+                            }]
+                    };
+                }
+                case 'confirm': {
+                    if (!message) {
+                        throw new Error("任务确认必须提供message参数");
+                    }
+                    let dialogMessage = `🎯 即将执行任务:\n${message}`;
+                    if (risks && risks.length > 0) {
+                        dialogMessage += `\n\n⚠️ 风险提示:\n${risks.map(risk => `• ${risk}`).join('\n')}`;
+                    }
+                    dialogMessage += `\n\n是否继续执行此任务？`;
+                    const dialogOptions = options || ["确认执行", "取消操作", "需要修改任务"];
+                    const interactiveServer = getInteractiveServer();
+                    const result = await interactiveServer.clarifyRequest(dialogMessage, dialogOptions);
+                    if (result.cancelled || (result.data && result.data.includes && result.data.includes('取消'))) {
+                        return { content: [{ type: "text", text: "❌ 用户取消了任务执行" }] };
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `✅ 用户确认: ${result.data}`
+                            }]
+                    };
+                }
+            }
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `交互对话出错: ${error instanceof Error ? error.message : String(error)}`
+                    }]
+            };
+        }
+    });
+}
+// 封装了获取环境、提示选择、保存配置的核心逻辑
+export async function _promptAndSetEnvironmentId(autoSelectSingle) {
+    // 1. 确保用户已登录
+    const loginState = await getLoginState();
+    debug('loginState', loginState);
+    if (!loginState) {
+        debug('请先登录云开发账户');
+        return { selectedEnvId: null, cancelled: false, error: "请先登录云开发账户" };
+    }
+    // 2. 获取可用环境列表
+    const cloudbase = await getCloudBaseManager({ requireEnvId: false });
+    const envResult = await cloudbase.env.listEnvs();
+    debug('envResult', envResult);
+    if (!envResult || !envResult.EnvList || envResult.EnvList.length === 0) {
+        return { selectedEnvId: null, cancelled: false, noEnvs: true };
+    }
+    const { EnvList } = envResult;
+    let selectedEnvId = null;
+    // 3. 根据情况选择或提示用户选择
+    if (autoSelectSingle && EnvList.length === 1 && EnvList[0].EnvId) {
+        selectedEnvId = EnvList[0].EnvId;
+    }
+    else {
+        const interactiveServer = getInteractiveServer();
+        const result = await interactiveServer.collectEnvId(EnvList);
+        if (result.cancelled) {
+            return { selectedEnvId: null, cancelled: true };
+        }
+        selectedEnvId = result.data;
+    }
+    // 4. 保存并设置环境ID
+    if (selectedEnvId) {
+        await saveEnvIdToUserConfig(selectedEnvId);
+        process.env.CLOUDBASE_ENV_ID = selectedEnvId;
+    }
+    return { selectedEnvId, cancelled: false };
+}
+// 获取用户配置文件路径
+function getUserConfigPath() {
+    return path.join(os.homedir(), '.cloudbase-env-id');
+}
+// 保存环境ID到用户配置文件
+async function saveEnvIdToUserConfig(envId) {
+    const configPath = getUserConfigPath();
+    try {
+        const config = {
+            envId,
+            updatedAt: new Date().toISOString(),
+            version: '1.0'
+        };
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+        // 环境ID已保存 - 静默操作避免干扰MCP返回值
+    }
+    catch (error) {
+        console.error('保存环境ID配置失败:', error);
+        throw error;
+    }
+}
+// 从用户配置文件读取环境ID
+async function loadEnvIdFromUserConfig() {
+    const configPath = getUserConfigPath();
+    try {
+        const configContent = await fs.readFile(configPath, 'utf8');
+        const config = JSON.parse(configContent);
+        const envId = config.envId || null;
+        if (!envId) {
+            warn(`Config file ${configPath} found, but 'envId' property is missing or empty.`);
+        }
+        return envId;
+    }
+    catch (err) {
+        // 文件不存在是正常情况，不应告警。只在文件存在但有问题时告警。
+        if (err.code !== 'ENOENT') {
+            warn(`Failed to load envId from config file at ${configPath}. Error: ${err.message}`);
+        }
+        else {
+            debug(`Env config file not found at ${configPath}, which is expected if not set.`);
+        }
+        return null;
+    }
+}
+// 检查并设置环境ID
+export async function ensureEnvId() {
+    // 优先使用进程环境变量
+    if (process.env.CLOUDBASE_ENV_ID) {
+        return process.env.CLOUDBASE_ENV_ID;
+    }
+    // 从用户配置文件读取
+    const envId = await loadEnvIdFromUserConfig();
+    if (envId) {
+        // 设置到进程环境变量中
+        process.env.CLOUDBASE_ENV_ID = envId;
+        return envId;
+    }
+    return null;
+}
+// 清理用户环境ID配置
+export async function clearUserEnvId() {
+    const configPath = getUserConfigPath();
+    try {
+        await fs.unlink(configPath);
+        // 清理进程环境变量
+        delete process.env.CLOUDBASE_ENV_ID;
+        delete process.env.TENCENTCLOUD_SECRETID;
+        delete process.env.TENCENTCLOUD_SECRETKEY;
+        delete process.env.TENCENTCLOUD_SESSIONTOKEN;
+        // 环境ID配置已清理 - 静默操作
+    }
+    catch (error) {
+        // 文件不存在或删除失败，忽略错误
+        // 环境ID配置文件不存在或已清理 - 静默操作
+    }
+}
+// 自动设置环境ID（无需MCP工具调用）
+export async function autoSetupEnvironmentId() {
+    try {
+        const { selectedEnvId, cancelled, error, noEnvs } = await _promptAndSetEnvironmentId(true);
+        if (error || noEnvs || cancelled) {
+            debug('Auto setup environment ID interrupted or failed silently.', { error, noEnvs, cancelled });
+            return null;
+        }
+        debug('Auto setup environment ID successful.', { selectedEnvId });
+        return selectedEnvId;
+    }
+    catch (error) {
+        console.error('自动配置环境ID时出错:', error);
+        return null;
+    }
+}

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