@cloudbase/cloudbase-mcp 1.8.41 → 1.8.43

package/dist/cli.cjs

@@ -1247,9 +1247,6 @@ function registerEnvTools(server) {
             if (error) {
                 return { content: [{ type: "text", text: error }] };
             }
-            if (noEnvs) {
-                return { content: [{ type: "text", text: "当前账户下暂无可用的云开发环境，请先在腾讯云控制台创建环境 https://tcb.cloud.tencent.com/dev?from=AIToolkit" }] };
-            }
             if (cancelled) {
                 return { content: [{ type: "text", text: "用户取消了登录" }] };
             }
@@ -1327,12 +1324,12 @@ function registerEnvTools(server) {
             switch (action) {
                 case "list":
                     try {
-                        const cloudbaseList = await (0, cloudbase_manager_js_1.getCloudBaseManager)({ cloudBaseOptions, requireEnvId: false });
+                        const cloudbaseList = await (0, cloudbase_manager_js_1.getCloudBaseManager)({ cloudBaseOptions, requireEnvId: true });
                         result = await cloudbaseList.env.listEnvs();
                     }
                     catch (error) {
                         (0, logger_js_1.debug)('获取环境列表时出错:', error);
-                        return { content: [{ type: "text", text: "当前账户下暂无可用的云开发环境，请先在腾讯云控制台创建环境 https://tcb.cloud.tencent.com/dev?from=AIToolkit \n错误信息:" + (error instanceof Error ? error.message : String(error)) }]
+                        return { content: [{ type: "text", text: "获取环境列表时出错: " + (error instanceof Error ? error.message : String(error)) }]
                         };
                     }
                     break;
@@ -22466,11 +22463,11 @@ exports.getEnvId = getEnvId;
 exports.resetCloudBaseManagerCache = resetCloudBaseManagerCache;
 exports.getCloudBaseManager = getCloudBaseManager;
 exports.createCloudBaseManagerWithOptions = createCloudBaseManagerWithOptions;
+const manager_node_1 = __importDefault(__webpack_require__(95492));
 const auth_js_1 = __webpack_require__(77291);
 const interactive_js_1 = __webpack_require__(3461);
-const manager_node_1 = __importDefault(__webpack_require__(95492));
 const logger_js_1 = __webpack_require__(13039);
-const ENV_ID_TIMEOUT = 600000; // 600 seconds
+const ENV_ID_TIMEOUT = 60000000; // 60000 seconds
 // 统一的环境ID管理类
 class EnvironmentManager {
     cachedEnvId = null;
@@ -22639,14 +22636,14 @@ exports.saveEnvIdToUserConfig = saveEnvIdToUserConfig;
 exports.loadEnvIdFromUserConfig = loadEnvIdFromUserConfig;
 exports.clearUserEnvId = clearUserEnvId;
 exports.autoSetupEnvironmentId = autoSetupEnvironmentId;
+const promises_1 = __importDefault(__webpack_require__(79748));
+const os_1 = __importDefault(__webpack_require__(21820));
+const path_1 = __importDefault(__webpack_require__(39902));
 const zod_1 = __webpack_require__(21614);
-const interactive_server_js_1 = __webpack_require__(92341);
-const cloudbase_manager_js_1 = __webpack_require__(3431);
 const auth_js_1 = __webpack_require__(77291);
+const cloudbase_manager_js_1 = __webpack_require__(3431);
+const interactive_server_js_1 = __webpack_require__(92341);
 const logger_js_1 = __webpack_require__(13039);
-const promises_1 = __importDefault(__webpack_require__(79748));
-const path_1 = __importDefault(__webpack_require__(39902));
-const os_1 = __importDefault(__webpack_require__(21820));
 function registerInteractiveTools(server) {
     // 统一的交互式对话工具 (cloud-incompatible)
     server.registerTool("interactiveDialog", {
@@ -33813,58 +33810,9 @@ function downloadFile(url) {
     });
 }
 function registerDownloadTools(server) {
-    // downloadRemoteFile - 下载远程文件到临时目录 (cloud-incompatible)
     server.registerTool("downloadRemoteFile", {
-        title: "下载远程文件到临时目录",
-        description: "下载远程文件到本地临时文件，返回一个系统的绝对路径。适用于需要临时处理文件的场景。",
-        inputSchema: {
-            url: zod_1.z.string().describe("远程文件的 URL 地址")
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: true,
-            category: "download"
-        }
-    }, async ({ url }) => {
-        try {
-            const result = await downloadFile(url);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            filePath: result.filePath,
-                            contentType: result.contentType,
-                            fileSize: result.fileSize,
-                            message: "文件下载成功到临时目录",
-                            note: "文件保存在临时目录中，请注意及时处理"
-                        }, null, 2)
-                    }
-                ]
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: error.message,
-                            message: "文件下载失败"
-                        }, null, 2)
-                    }
-                ]
-            };
-        }
-    });
-    // downloadRemoteFileToPath - 下载远程文件到指定路径 (cloud-incompatible)
-    server.registerTool("downloadRemoteFileToPath", {
         title: "下载远程文件到指定路径",
-        description: "下载远程文件到项目根目录下的指定相对路径。Claude Code: WORKSPACE_FOLDER_PATHS, Qwen Code: PROJECT_ROOT, CodeBuddy: GITHUB_WORKSPACE。例如：小程序的 Tabbar 等素材图片，必须使用 **png** 格式，可以从 Unsplash、wikimedia【一般选用 500 大小即可、Pexels、Apple 官方 UI 等资源中选择来下载。",
+        description: "下载远程文件到项目根目录下的指定相对路径。例如：小程序的 Tabbar 等素材图片，必须使用 **png** 格式，可以从 Unsplash、wikimedia【一般选用 500 大小即可、Pexels、Apple 官方 UI 等资源中选择来下载。",
         inputSchema: {
             url: zod_1.z.string().describe("远程文件的 URL 地址"),
             relativePath: zod_1.z.string().describe("相对于项目根目录的路径，例如：'assets/images/logo.png' 或 'docs/api.md'。不允许使用 ../ 等路径遍历操作。")
@@ -97937,7 +97885,7 @@ function convertToJSONSchema(data) {
                         // 处理枚举类型
                         if (parsed.type.startsWith('x-enum')) {
                             schema.properties[parsed.name].type = 'string';
-                            schema.properties[parsed.name].format = 'enum';
+                            schema.properties[parsed.name].format = 'x-enum';
                             if (parsed.enumValues) {
                                 schema.properties[parsed.name].enum = parsed.enumValues;
                             }
@@ -98124,7 +98072,6 @@ function getSpecialFormat(type) {
         'x-location': 'x-location',
         'x-area-code': 'x-area-code',
         'x-file': 'x-file',
-        'x-enum': 'enum',
     };
     // 只保留这些
     return formatMap[type] || null;
@@ -101615,11 +101562,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.CLOUDRUN_ACCESS_TYPES = exports.CLOUDRUN_SERVICE_TYPES = void 0;
 exports.registerCloudRunTools = registerCloudRunTools;
+const child_process_1 = __webpack_require__(79646);
+const fs_1 = __importDefault(__webpack_require__(29021));
+const path_1 = __importDefault(__webpack_require__(39902));
 const zod_1 = __webpack_require__(21614);
 const cloudbase_manager_js_1 = __webpack_require__(3431);
-const path_1 = __importDefault(__webpack_require__(39902));
-const fs_1 = __importDefault(__webpack_require__(29021));
-const child_process_1 = __webpack_require__(79646);
 // CloudRun service types
 exports.CLOUDRUN_SERVICE_TYPES = ['function', 'container'];
 // CloudRun access types
@@ -101631,7 +101578,7 @@ const queryCloudRunInputSchema = {
     pageSize: zod_1.z.number().min(1).max(100).optional().default(10).describe('分页大小，控制每页返回的服务数量。取值范围：1-100，默认值：10。建议根据网络性能和显示需求调整'),
     pageNum: zod_1.z.number().min(1).optional().default(1).describe('页码，用于分页查询。从1开始，默认值：1。配合pageSize使用可实现分页浏览'),
     serverName: zod_1.z.string().optional().describe('服务名称筛选条件，支持模糊匹配。例如：输入"test"可匹配"test-service"、"my-test-app"等服务名称。留空则查询所有服务'),
-    serverType: zod_1.z.enum(exports.CLOUDRUN_SERVICE_TYPES).optional().describe('服务类型筛选条件：function=函数型云托管（简化开发模式，支持WebSocket/SSE/文件上传等特性，适合快速开发），container=容器型服务（传统容器部署模式，支持任意语言和框架，适合复杂应用）'),
+    serverType: zod_1.z.enum(exports.CLOUDRUN_SERVICE_TYPES).optional().describe('服务类型筛选条件：function=函数型云托管（仅支持Node.js，有特殊的开发要求和限制，适合简单的API服务），container=容器型服务（推荐使用，支持任意语言和框架如Java/Go/Python/PHP/.NET等，适合大多数应用场景）'),
     // Detail operation parameters
     detailServerName: zod_1.z.string().optional().describe('要查询详细信息的服务名称。当action为detail时必需提供，必须是已存在的服务名称。可通过list操作获取可用的服务名称列表'),
 };
@@ -101645,7 +101592,7 @@ const ManageCloudRunInputSchema = {
         OpenAccessTypes: zod_1.z.array(zod_1.z.enum(exports.CLOUDRUN_ACCESS_TYPES)).optional().describe('公网访问类型配置，控制服务的访问权限：WEB=公网访问（默认，可通过HTTPS域名访问），VPC=私有网络访问（仅同VPC内可访问），PRIVATE=内网访问（仅云开发环境内可访问）。可配置多个类型'),
         Cpu: zod_1.z.number().positive().optional().describe('CPU规格配置，单位为核。可选值：0.25、0.5、1、2、4、8等。注意：内存规格必须是CPU规格的2倍（如CPU=0.25时内存=0.5，CPU=1时内存=2）。影响服务性能和计费'),
         Mem: zod_1.z.number().positive().optional().describe('内存规格配置，单位为GB。可选值：0.5、1、2、4、8、16等。注意：必须是CPU规格的2倍。影响服务性能和计费'),
-        MinNum: zod_1.z.number().min(0).optional().describe('最小实例数配置，控制服务的最小运行实例数量。设置为0时支持缩容到0（无请求时不产生费用），设置为大于0时始终保持指定数量的实例运行（确保快速响应但会增加成本）'),
+        MinNum: zod_1.z.number().min(0).optional().describe('最小实例数配置，控制服务的最小运行实例数量。设置为0时支持缩容到0（无请求时不产生费用），设置为大于0时始终保持指定数量的实例运行（确保快速响应但会增加成本）。建议设置为1以降低冷启动延迟，提升用户体验'),
         MaxNum: zod_1.z.number().min(1).optional().describe('最大实例数配置，控制服务的最大运行实例数量。当请求量增加时，服务最多可以扩展到指定数量的实例，超过此数量后将拒绝新的请求。建议根据业务峰值设置'),
         Port: zod_1.z.number().min(1).max(65535).optional().describe('服务监听端口配置。函数型服务固定为3000，容器型服务可自定义。服务代码必须监听此端口才能正常接收请求'),
         EnvParams: zod_1.z.record(zod_1.z.string()).optional().describe('环境变量配置，用于传递配置信息给服务代码。格式为键值对，如{"DATABASE_URL":"mysql://..."}。敏感信息建议使用环境变量而非硬编码'),
@@ -101673,6 +101620,7 @@ const ManageCloudRunInputSchema = {
     }).optional().describe('Agent配置项，仅在createAgent操作时使用'),
     // Common parameters
     force: zod_1.z.boolean().optional().default(false).describe('强制操作开关，用于跳过确认提示。默认false（需要确认），设置为true时跳过所有确认步骤。删除操作时强烈建议设置为true以避免误操作'),
+    serverType: zod_1.z.enum(exports.CLOUDRUN_SERVICE_TYPES).optional().describe('服务类型配置：function=函数型云托管（仅支持Node.js，有特殊的开发要求和限制，适合简单的API服务），container=容器型服务（推荐使用，支持任意语言和框架如Java/Go/Python/PHP/.NET等，适合大多数应用场景）。不提供时自动检测：1)现有服务类型 2)有Dockerfile→container 3)有@cloudbase/aiagent-framework依赖→function 4)其他情况→container'),
 };
 /**
  * Check if a project is an Agent project
@@ -102047,21 +101995,47 @@ for await (let x of res.textStream) {
                     if (!targetPath) {
                         throw new Error("targetPath is required for deploy operation");
                     }
-                    // Determine service type automatically
+                    // Determine service type - use input.serverType if provided, otherwise auto-detect
                     let serverType;
-                    try {
-                        // First try to get existing service details
-                        const details = await cloudrunService.detail({ serverName: input.serverName });
-                        serverType = details.BaseInfo?.ServerType || 'function';
+                    if (input.serverType) {
+                        serverType = input.serverType;
                     }
-                    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 {
+                        try {
+                            // First try to get existing service details
+                            const details = await cloudrunService.detail({ serverName: input.serverName });
+                            serverType = details.BaseInfo?.ServerType || 'container';
                         }
-                        else {
-                            serverType = 'function';
+                        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';
+                                        }
+                                    }
+                                    catch (parseError) {
+                                        serverType = 'container';
+                                    }
+                                }
+                                else {
+                                    // No package.json, default to container
+                                    serverType = 'container';
+                                }
+                            }
                         }
                     }
                     const deployParams = {
@@ -122142,7 +122116,7 @@ class TelemetryReporter {
         const nodeVersion = process.version; // Node.js版本
         const arch = os_1.default.arch(); // 系统架构
         // 从构建时注入的版本号获取MCP版本信息
-        const mcpVersion = process.env.npm_package_version || "1.8.41" || 0;
+        const mcpVersion = process.env.npm_package_version || "1.8.43" || 0;
         return {
             userAgent: `${osType} ${osRelease} ${arch} ${nodeVersion} CloudBase-MCP/${mcpVersion}`,
             deviceId: this.deviceId,
@@ -180028,7 +180002,7 @@ ${envIdSection}
 ## 环境信息
 - 操作系统: ${os_1.default.type()} ${os_1.default.release()}
 - Node.js版本: ${process.version}
-- MCP 版本：${process.env.npm_package_version || "1.8.41" || 0}
+- MCP 版本：${process.env.npm_package_version || "1.8.43" || 0}
 - 系统架构: ${os_1.default.arch()}
 - 时间: ${new Date().toISOString()}
 - 请求ID: ${requestId}
@@ -195054,7 +195028,7 @@ function registerSetupTools(server) {
     // downloadTemplate - 下载项目模板 (cloud-incompatible)
     server.registerTool("downloadTemplate", {
         title: "下载项目模板",
-        description: `自动下载并部署CloudBase项目模板。\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- 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- vscode: Visual Studio Code\n\n特别说明：\n- rules 模板会自动包含当前 mcp 版本号信息（版本号：${ true ? "1.8.41" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
+        description: `自动下载并部署CloudBase项目模板。\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- 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- vscode: Visual Studio Code\n\n特别说明：\n- rules 模板会自动包含当前 mcp 版本号信息（版本号：${ true ? "1.8.43" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
         inputSchema: {
             template: zod_1.z.enum(["react", "vue", "miniprogram", "uniapp", "rules"]).describe("要下载的模板类型"),
             ide: zod_1.z.enum(IDE_TYPES).optional().default("all").describe("指定要下载的IDE类型，默认为all（下载所有IDE配置）"),
@@ -196263,9 +196237,9 @@ async function getLoginState() {
     }
     const loginState = await auth.getLoginState();
     if (!loginState) {
-        (0, logger_js_1.debug)('loginByApiSecret');
         await auth.loginByWebAuth({});
         const loginState = await auth.getLoginState();
+        (0, logger_js_1.debug)('loginByWebAuth', loginState);
         return loginState;
     }
     else {
@@ -219678,7 +219652,11 @@ function shouldRegisterTool(toolName) {
         'setupEnvironmentId',
         'clearUserEnvId',
         // Interactive tools - local server and file operations
-        'interactiveDialog'
+        'interactiveDialog',
+        // CloudRun tools - local file operations
+        'manageCloudRun',
+        // Download tools - local file downloads
+        'manageStorage',
     ];
     const shouldRegister = !cloudIncompatibleTools.includes(toolName);
     if (!shouldRegister) {
@@ -228562,8 +228540,8 @@ exports.resetInteractiveServer = resetInteractiveServer;
 exports.getInteractiveServerSafe = getInteractiveServerSafe;
 const express_1 = __importDefault(__webpack_require__(26083));
 const http_1 = __importDefault(__webpack_require__(81630));
-const ws_1 = __webpack_require__(17699);
 const open_1 = __importDefault(__webpack_require__(45368));
+const ws_1 = __webpack_require__(17699);
 const logger_js_1 = __webpack_require__(13039);
 // 动态导入 open 模块，兼容 ESM/CJS 环境
 async function openUrl(url, options, server) {
@@ -229446,8 +229424,8 @@ class InteractiveServer {
         </div>
 
         <div class="content">
-            <h1 class="content-title">选择云开发环境</h1>
-            <p class="content-subtitle">请选择您要使用的云开发环境</p>
+            <h1 class="content-title">选择 CloudBase 环境</h1>
+            <p class="content-subtitle">请选择您要使用的 CloudBase 环境</p>
             
             <div class="env-list" id="envList">
                 ${(envs || []).length > 0 ?
@@ -229464,8 +229442,8 @@ class InteractiveServer {
                     `).join('') :
             `
                     <div class="empty-state">
-                        <h3 class="empty-title">暂无云开发环境</h3>
-                        <p class="empty-message">当前没有可用的云开发 CloudBase 环境，请新建后重新在 AI 对话中重试</p>
+                        <h3 class="empty-title">暂无 CloudBase 环境</h3>
+                        <p class="empty-message">当前没有可用的 CloudBase 环境，请新建后重新在 AI 对话中重试</p>
                         <button class="btn btn-primary create-env-btn" onclick="createNewEnv()">
                             <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                                 <path d="M12 5v14M5 12h14"/>
@@ -229503,7 +229481,7 @@ class InteractiveServer {
                     </svg>
                 </div>
                 <h2 class="success-title">环境配置成功！</h2>
-                <p class="success-message">已成功选择云开发环境</p>
+                <p class="success-message">已成功选择 CloudBase 环境</p>
                 <div class="selected-env-info">
                     <span class="env-label">环境 ID:</span>
                     <span class="env-value" id="selectedEnvDisplay"></span>
@@ -237134,54 +237112,285 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.registerStorageTools = registerStorageTools;
 const zod_1 = __webpack_require__(21614);
 const cloudbase_manager_js_1 = __webpack_require__(3431);
+// Input schema for queryStorage tool
+const queryStorageInputSchema = {
+    action: zod_1.z.enum(['list', 'info', 'url']).describe('查询操作类型：list=列出目录下的所有文件，info=获取指定文件的详细信息，url=获取文件的临时下载链接'),
+    cloudPath: zod_1.z.string().describe('云端文件路径，例如 files/data.txt 或 files/（目录）'),
+    maxAge: zod_1.z.number().min(1).max(86400).optional().default(3600).describe('临时链接有效期，单位为秒，取值范围：1-86400，默认值：3600（1小时）')
+};
+// Input schema for manageStorage tool
+const manageStorageInputSchema = {
+    action: zod_1.z.enum(['upload', 'download', 'delete']).describe('管理操作类型：upload=上传文件或目录，download=下载文件或目录，delete=删除文件或目录'),
+    localPath: zod_1.z.string().describe('本地文件路径，建议传入绝对路径，例如 /tmp/files/data.txt'),
+    cloudPath: zod_1.z.string().describe('云端文件路径，例如 files/data.txt'),
+    force: zod_1.z.boolean().optional().default(false).describe('强制操作开关，删除操作时建议设置为true以确认删除，默认false'),
+    isDirectory: zod_1.z.boolean().optional().default(false).describe('是否为目录操作，true=目录操作，false=文件操作，默认false')
+};
 function registerStorageTools(server) {
     // 获取 cloudBaseOptions，如果没有则为 undefined
     const cloudBaseOptions = server.cloudBaseOptions;
     // 创建闭包函数来获取 CloudBase Manager
     const getManager = () => (0, cloudbase_manager_js_1.getCloudBaseManager)({ cloudBaseOptions });
-    // uploadFile - 上传文件到云存储 (cloud-incompatible)
-    server.registerTool("uploadFile", {
-        title: "上传文件到云存储",
-        description: "上传文件到云存储（区别于静态网站托管，云存储更适合存储业务数据文件）",
-        inputSchema: {
-            localPath: zod_1.z.string().describe("本地文件路径，建议传入绝对路径，例如 /tmp/files/data.txt"),
-            cloudPath: zod_1.z.string().describe("云端文件路径，例如 files/data.txt")
-        },
+    // Tool 1: queryStorage - 查询存储信息（只读操作）
+    server.registerTool("queryStorage", {
+        title: "查询存储信息",
+        description: "查询云存储信息，支持列出目录文件、获取文件信息、获取临时下载链接等只读操作。返回的文件信息包括文件名、大小、修改时间、下载链接等。",
+        inputSchema: queryStorageInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            openWorldHint: true,
+            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}`);
+            }
+        }
+        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)
+                    }
+                ]
+            };
+        }
+    });
+    // Tool 2: manageStorage - 管理存储文件（写操作）
+    server.registerTool("manageStorage", {
+        title: "管理存储文件",
+        description: "管理云存储文件，支持上传文件/目录、下载文件/目录、删除文件/目录等操作。删除操作需要设置force=true进行确认，防止误删除重要文件。",
+        inputSchema: manageStorageInputSchema,
         annotations: {
             readOnlyHint: false,
-            destructiveHint: false,
+            destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
             category: "storage"
         }
-    }, async ({ localPath, cloudPath }) => {
-        const cloudbase = await getManager();
-        // 上传文件
-        await cloudbase.storage.uploadFile({
-            localPath,
-            cloudPath,
-            onProgress: (progressData) => {
-                console.log("Upload progress:", progressData);
+    }, 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 fileUrls = await cloudbase.storage.getTemporaryUrl([{
-                cloudPath: cloudPath,
-                maxAge: 3600 // 临时链接有效期1小时
-            }]);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        message: "文件上传成功",
-                        cloudPath: cloudPath,
-                        temporaryUrl: fileUrls[0]?.url || "",
-                        expireTime: "1小时"
-                    }, null, 2)
+            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)
+                            }
+                        ]
+                    };
                 }
-            ]
-        };
+                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: 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]);
+                    }
+                    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)
+                            }
+                        ]
+                    };
+                }
+                default:
+                    throw new Error(`Unsupported action: ${input.action}`);
+            }
+        }
+        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)
+                    }
+                ]
+            };
+        }
     });
 }