@cloudbase/cloudbase-mcp 1.5.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/functions.js

@@ -1,5 +1,15 @@
 import { z } from "zod";
 import { getCloudBaseManager } from '../cloudbase-manager.js';
+// 支持的 Node.js 运行时列表
+export const SUPPORTED_NODEJS_RUNTIMES = [
+    'Nodejs 18.15',
+    'Nodejs 16.13',
+    'Nodejs 14.18',
+    'Nodejs 12.16',
+    'Nodejs 10.15',
+    'Nodejs 8.9（即将下线）',
+];
+export const DEFAULT_NODEJS_RUNTIME = 'Nodejs 18.15';
 export function registerFunctionTools(server) {
     // getFunctionList - 获取云函数列表(推荐)
     server.tool("getFunctionList", "获取云函数列表", {
@@ -27,7 +37,7 @@ export function registerFunctionTools(server) {
                 vpcId: z.string(),
                 subnetId: z.string()
             }).optional().describe("私有网络配置"),
-            runtime: z.string().optional().describe("运行时环境"),
+            runtime: z.string().optional().describe("运行时环境，可选值：" + SUPPORTED_NODEJS_RUNTIMES.join('，') + "，默认 Nodejs 18.15"),
             installDependency: z.boolean().optional().describe("是否安装依赖，建议传 true"),
             triggers: z.array(z.object({
                 name: z.string(),
@@ -45,6 +55,10 @@ export function registerFunctionTools(server) {
         functionRootPath: z.string().optional().describe("函数根目录（云函数目录的父目录），这里需要传操作系统上文件的绝对路径，指定之后可以自动上传这部分的文件作为代码"),
         force: z.boolean().describe("是否覆盖")
     }, async ({ func, functionRootPath, force }) => {
+        // 自动填充默认 runtime
+        if (!func.runtime) {
+            func.runtime = DEFAULT_NODEJS_RUNTIME;
+        }
         const cloudbase = await getCloudBaseManager();
         const result = await cloudbase.functions.createFunction({
             func,
@@ -94,9 +108,13 @@ export function registerFunctionTools(server) {
                 vpcId: z.string(),
                 subnetId: z.string()
             }).optional().describe("VPC配置"),
-            runtime: z.string().optional().describe("运行时")
+            runtime: z.string().optional().describe("运行时（可选值：" + SUPPORTED_NODEJS_RUNTIMES.join('，') + "，默认 Nodejs 18.15)")
         }).describe("函数配置")
     }, async ({ funcParam }) => {
+        // 自动填充默认 runtime
+        if (!funcParam.runtime) {
+            funcParam.runtime = DEFAULT_NODEJS_RUNTIME;
+        }
         const cloudbase = await getCloudBaseManager();
         const result = await cloudbase.functions.updateFunctionConfig(funcParam);
         return {

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/tools/rag.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
 // 1. 枚举定义
-const KnowledgeBaseEnum = z.enum(["cloudbase", "scf"]);
+const KnowledgeBaseEnum = z.enum(["cloudbase", "scf", "miniprogram"]);
 // 2. 枚举到后端 id 的映射
 const KnowledgeBaseIdMap = {
     cloudbase: "ykfzskv4_ad28",
     scf: "scfsczskzyws_4bdc",
+    miniprogram: "xcxzskws_25d8",
 };
 // 安全 JSON.parse
 function safeParse(str) {
@@ -36,7 +37,7 @@ export function registerRagTools(server) {
     // 知识库检索
     server.tool('searchKnowledgeBase', '云开发知识库智能检索工具，支持云开发与云函数知识的向量查询', {
         threshold: z.number().default(0.5).optional().describe("相似性检索阈值"),
-        id: KnowledgeBaseEnum.describe("知识库范围，cloudbase=云开发全量知识，scf=云开发的云函数知识"),
+        id: KnowledgeBaseEnum.describe("知识库范围，cloudbase=云开发全量知识，scf=云开发的云函数知识, miniprogram=小程序知识（不包含云开发与云函数知识）"),
         content: z.string().describe("检索内容"),
         options: z.object({
             chunkExpand: z.array(z.number()).min(2).max(2).default([3, 3]).describe("指定返回的文档内容的展开长度,例如 [3,3]代表前后展开长度"),

package/dist/tools/setup.js

@@ -0,0 +1,186 @@
+import { z } from "zod";
+import * as fs from "fs";
+import * as fsPromises from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import * as https from "https";
+import * as http from "http";
+import * as unzipper from "unzipper";
+// CloudBase 模板配置
+const TEMPLATES = {
+    "react": {
+        description: "React + CloudBase 全栈应用模板",
+        url: "https://static.cloudbase.net/cloudbase-examples/web-cloudbase-react-template.zip"
+    },
+    "miniprogram": {
+        description: "微信小程序 + 云开发模板",
+        url: "https://static.cloudbase.net/cloudbase-examples/miniprogram-cloudbase-miniprogram-template.zip"
+    },
+    "rules": {
+        description: "AI编辑器配置模板（包含所有主流编辑器配置）",
+        url: "https://static.cloudbase.net/cloudbase-examples/web-cloudbase-project.zip"
+    }
+};
+// 下载文件到临时目录
+async function downloadFile(url, filePath) {
+    return new Promise((resolve, reject) => {
+        const client = url.startsWith('https:') ? https : http;
+        client.get(url, (res) => {
+            if (res.statusCode === 200) {
+                const file = fs.createWriteStream(filePath);
+                res.pipe(file);
+                file.on('finish', () => {
+                    file.close();
+                    resolve();
+                });
+                file.on('error', reject);
+            }
+            else if (res.statusCode === 302 || res.statusCode === 301) {
+                // 处理重定向
+                if (res.headers.location) {
+                    downloadFile(res.headers.location, filePath).then(resolve).catch(reject);
+                }
+                else {
+                    reject(new Error('重定向但没有location header'));
+                }
+            }
+            else {
+                reject(new Error(`下载失败，状态码: ${res.statusCode}`));
+            }
+        }).on('error', reject);
+    });
+}
+// 解压ZIP文件
+async function extractZip(zipPath, extractPath) {
+    try {
+        // 创建解压目录
+        await fsPromises.mkdir(extractPath, { recursive: true });
+        // 使用 unzipper 库进行解压，兼容性更好
+        await fs.createReadStream(zipPath)
+            .pipe(unzipper.Extract({ path: extractPath }))
+            .promise();
+    }
+    catch (error) {
+        throw new Error(`解压失败: ${error instanceof Error ? error.message : '未知错误'}`);
+    }
+}
+// 获取目录下所有文件的相对路径列表
+async function getAllFiles(dir, baseDir = dir) {
+    const files = [];
+    const entries = await fsPromises.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const subFiles = await getAllFiles(fullPath, baseDir);
+            files.push(...subFiles);
+        }
+        else {
+            files.push(path.relative(baseDir, fullPath));
+        }
+    }
+    return files;
+}
+// 复制文件，不覆盖已存在的文件
+async function copyFileIfNotExists(src, dest) {
+    try {
+        // 检查目标文件是否存在
+        if (fs.existsSync(dest)) {
+            return { copied: false, reason: '文件已存在' };
+        }
+        // 创建目标目录
+        await fsPromises.mkdir(path.dirname(dest), { recursive: true });
+        // 复制文件
+        await fsPromises.copyFile(src, dest);
+        return { copied: true };
+    }
+    catch (error) {
+        return { copied: false, reason: `复制失败: ${error instanceof Error ? error.message : '未知错误'}` };
+    }
+}
+export function registerSetupTools(server) {
+    server.tool("downloadTemplate", `自动下载并部署CloudBase项目模板。
+
+支持的模板:
+- react: React + CloudBase 全栈应用模板
+- miniprogram: 微信小程序 + 云开发模板  
+- rules: 只包含AI编辑器配置文件（包含Cursor、WindSurf、CodeBuddy等所有主流编辑器配置），适合在已有项目中补充AI编辑器配置
+
+工具会自动下载模板到临时目录，解压后如果检测到WORKSPACE_FOLDER_PATHS环境变量，则复制到项目目录（不覆盖已存在文件）。`, {
+        template: z.enum(["react", "miniprogram", "rules"]).describe("要下载的模板类型")
+    }, async ({ template }) => {
+        try {
+            const templateConfig = TEMPLATES[template];
+            if (!templateConfig) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ 不支持的模板类型: ${template}`
+                        }
+                    ]
+                };
+            }
+            // 创建临时目录
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cloudbase-template-'));
+            const zipPath = path.join(tempDir, 'template.zip');
+            const extractDir = path.join(tempDir, 'extracted');
+            // 下载和解压
+            await downloadFile(templateConfig.url, zipPath);
+            await extractZip(zipPath, extractDir);
+            const extractedFiles = await getAllFiles(extractDir);
+            // 检查是否需要复制到项目目录
+            const workspaceFolder = process.env.WORKSPACE_FOLDER_PATHS;
+            let finalFiles = [];
+            let copiedCount = 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);
+                    if (copyResult.copied) {
+                        copiedCount++;
+                        finalFiles.push(destPath);
+                    }
+                    else {
+                        skippedCount++;
+                        finalFiles.push(srcPath);
+                    }
+                }
+                results.push(`✅ ${templateConfig.description} 同步完成`);
+                results.push(`📁 保存在临时目录: ${extractDir}`);
+                results.push(`📊 复制了 ${copiedCount} 个文件${skippedCount > 0 ? `，跳过 ${skippedCount} 个已存在文件` : ''}`);
+            }
+            else {
+                finalFiles = extractedFiles.map(relativePath => path.join(extractDir, relativePath));
+                results.push(`✅ ${templateConfig.description} 下载完成`);
+                results.push(`📁 保存在临时目录: ${extractDir}`);
+            }
+            // 文件路径列表
+            results.push('');
+            results.push('📋 文件列表:');
+            finalFiles.forEach(filePath => {
+                results.push(`${filePath}`);
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: results.join('\n')
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ 下载模板失败: ${error instanceof Error ? error.message : '未知错误'}`
+                    }
+                ]
+            };
+        }
+    });
+}

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