@cloudbase/cloudbase-mcp 1.6.0 → 1.7.0

package/dist/tools/env.js

@@ -1,26 +1,72 @@
 import { z } from "zod";
 import { getCloudBaseManager } from '../cloudbase-manager.js';
 import { logout } from '../auth.js';
+import { clearUserEnvId, _promptAndSetEnvironmentId } from './interactive.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);
+            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/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.response}`
+                            }]
+                    };
+                }
+                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.response.includes('取消')) {
+                        return { content: [{ type: "text", text: "❌ 用户取消了任务执行" }] };
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `✅ 用户确认: ${result.data.response}`
+                            }]
+                    };
+                }
+            }
+        }
+        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.envId;
+    }
+    // 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/utils/logger.js

@@ -0,0 +1,119 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+class Logger {
+    enabled;
+    level;
+    logFile;
+    useConsole;
+    constructor(options = {}) {
+        // 通过环境变量控制是否启用日志
+        this.enabled = options.enabled ?? (process.env.MCP_DEBUG === 'true' || process.env.NODE_ENV === 'development');
+        this.level = options.level ?? LogLevel.INFO;
+        this.useConsole = options.console ?? false;
+        // 默认日志文件路径
+        this.logFile = options.logFile ?? path.join(os.tmpdir(), 'cloudbase-mcp.log');
+    }
+    async writeLog(level, message, data) {
+        if (!this.enabled || level < this.level)
+            return;
+        const timestamp = new Date().toISOString();
+        const levelName = LogLevel[level];
+        const logMessage = data
+            ? `[${timestamp}] [${levelName}] ${message} ${JSON.stringify(data, null, 2)}`
+            : `[${timestamp}] [${levelName}] ${message}`;
+        // 输出到控制台（仅在调试模式下）
+        if (this.useConsole && process.env.NODE_ENV === 'development') {
+            console.error(logMessage); // 使用 stderr 避免污染 stdout
+        }
+        // 写入日志文件
+        if (this.logFile) {
+            try {
+                await fs.appendFile(this.logFile, logMessage + '\n');
+            }
+            catch (error) {
+                // 静默处理日志写入错误，避免影响主要功能
+            }
+        }
+    }
+    debug(message, data) {
+        this.writeLog(LogLevel.DEBUG, message, data);
+    }
+    info(message, data) {
+        this.writeLog(LogLevel.INFO, message, data);
+    }
+    warn(message, data) {
+        this.writeLog(LogLevel.WARN, message, data);
+    }
+    error(message, data) {
+        this.writeLog(LogLevel.ERROR, message, data);
+    }
+    // 设置日志级别
+    setLevel(level) {
+        this.level = level;
+    }
+    // 启用/禁用日志
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    // 获取日志文件路径
+    getLogFile() {
+        return this.logFile;
+    }
+    // 清理日志文件
+    async clearLogs() {
+        if (this.logFile) {
+            try {
+                await fs.writeFile(this.logFile, '');
+            }
+            catch (error) {
+                // 静默处理
+            }
+        }
+    }
+    // 读取日志内容
+    async getLogs(maxLines = 1000) {
+        if (!this.logFile)
+            return [];
+        try {
+            const content = await fs.readFile(this.logFile, 'utf-8');
+            const lines = content.split('\n').filter(line => line.trim());
+            // 返回最近的 maxLines 行
+            return lines.slice(-maxLines);
+        }
+        catch (error) {
+            return [`读取日志文件失败: ${error instanceof Error ? error.message : String(error)}`];
+        }
+    }
+    // 获取日志状态信息
+    getStatus() {
+        return {
+            enabled: this.enabled,
+            level: LogLevel[this.level],
+            logFile: this.logFile,
+            useConsole: this.useConsole
+        };
+    }
+}
+// 创建全局 logger 实例
+export const logger = new Logger({
+    enabled: process.env.MCP_DEBUG === 'true',
+    level: LogLevel.INFO,
+    console: process.env.NODE_ENV === 'development'
+});
+// 便捷的导出函数
+export const debug = (message, data) => logger.error(message, data);
+export const info = (message, data) => logger.info(message, data);
+export const warn = (message, data) => logger.warn(message, data);
+export const error = (message, data) => logger.error(message, data);
+// 日志管理函数
+export const getLogs = (maxLines) => logger.getLogs(maxLines);
+export const getLoggerStatus = () => logger.getStatus();
+export const clearLogs = () => logger.clearLogs();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudbase/cloudbase-mcp",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "腾讯云开发 MCP Server，支持静态托管/环境查询/",
   "main": "index.js",
   "type": "module",
@@ -30,11 +30,17 @@
     "@cloudbase/toolbox": "^0.7.5",
     "@modelcontextprotocol/sdk": "1.9.0",
     "@types/unzipper": "^0.10.11",
+    "cors": "^2.8.5",
+    "express": "^5.1.0",
+    "open": "^10.1.2",
     "unzipper": "^0.12.3",
+    "ws": "^8.18.2",
     "zod": "^3.24.3"
   },
   "devDependencies": {
+    "@types/express": "^5.0.3",
     "@types/node": "^22.14.1",
+    "@types/ws": "^8.18.1",
     "typescript": "^5.8.3"
   }
 }