@junjun-org/bd-ke-mcp 1.0.0 → 1.0.1

package/index.js

@@ -78,7 +78,7 @@ function loadConfig() {
     const fileContent = fs.readFileSync(configFile, "utf8");
     const fileConfig = JSON.parse(fileContent);
     Object.assign(config, fileConfig);
-    logger.info("已加载配置文件", { path: configFile });
+    logger.debug("已加载配置文件", { path: configFile });
   } catch (error) {
     logger.error("配置文件加载失败", { error: error.message });
   }
@@ -143,16 +143,23 @@ async function fetchWithTimeout(url, options = {}, timeoutMs = FETCH_TIMEOUT) {
 
 /**
  * KE API 请求
+ * @param {string} method - HTTP 方法
+ * @param {string} urlPath - API 路径
+ * @param {Object} options - 请求选项
+ * @param {string} options.domain - KE 平台域名，未指定时从配置文件获取
+ * @param {string} options.access_token - 访问令牌，未指定时从配置文件获取
+ * @param {Object} options.body - 请求体
+ * @param {Object} options.headers - 额外的请求头
  */
 async function keRequest(method, urlPath, options = {}) {
-  const domain = getConfig("domain");
-  const accessToken = getConfig("access_token");
+  const domain = options.domain || getConfig("domain");
+  const accessToken = options.access_token || getConfig("access_token");
 
   if (!domain) {
-    throw new Error("配置项 domain 未设置");
+    throw new Error("参数 domain 未指定且配置文件中未设置");
   }
   if (!accessToken) {
-    throw new Error("配置项 access_token 未设置");
+    throw new Error("参数 access_token 未指定且配置文件中未设置");
   }
 
   const url = `${domain.replace(/\/+$/, "")}/${urlPath.replace(/^\/+/, "")}`;
@@ -187,26 +194,135 @@ async function keRequest(method, urlPath, options = {}) {
 
 // ==================== 工具实现 ====================
 
+/**
+· * ke_config_reset - 重置/更新 KE MCP 配置参数
+ * 将配置写入当前项目空间下的 .mcp/bd-ke-mcp.json 文件
+ * @param {Object} config - 配置选项
+ * @param {string} config.domain - KE 平台域名（用户输入）
+ * @param {string} config.access_token - 访问令牌（用户输入）
+ * @param {string} config.tenant - 租户名称（从 ke_tenants_list 获取后选择）
+ * @param {string} config.project - 项目名称（从 ke_projects_list 获取后选择）
+ * @param {string} config.application - 应用名称（从 ke_app_list 获取后选择）
+ * @param {string} config.env - 环境名称（从 ke_env_list 获取后选择）
+ */
+async function keConfigReset(config) {
+  const projectRoot = getProjectRoot();
+  
+  if (!projectRoot) {
+    throw new Error("PROJECT_ROOT 环境变量未设置，无法确定项目路径");
+  }
+
+  const mcpDir = path.join(projectRoot, ".mcp");
+  const configFile = path.join(mcpDir, CONFIG_FILE_NAME);
+
+  // 确保 .mcp 目录存在
+  if (!fs.existsSync(mcpDir)) {
+    fs.mkdirSync(mcpDir, { recursive: true });
+    logger.info("已创建 .mcp 目录", { path: mcpDir });
+  }
+
+  // 读取现有配置（如果存在）
+  let existingConfig = {};
+  if (fs.existsSync(configFile)) {
+    try {
+      const fileContent = fs.readFileSync(configFile, "utf8");
+      existingConfig = JSON.parse(fileContent);
+      logger.info("已读取现有配置文件", { path: configFile });
+    } catch (error) {
+      logger.warn("读取现有配置文件失败，将创建新配置", { error: error.message });
+    }
+  }
+
+  // 合并配置（新配置覆盖旧配置）
+  const newConfig = { ...existingConfig };
+  
+  // 只更新提供的非空配置项
+  if (config.domain !== undefined && config.domain !== "") {
+    newConfig.domain = config.domain;
+  }
+  if (config.access_token !== undefined && config.access_token !== "") {
+    newConfig.access_token = config.access_token;
+  }
+  if (config.tenant !== undefined && config.tenant !== "") {
+    newConfig.tenant = config.tenant;
+  }
+  if (config.project !== undefined && config.project !== "") {
+    newConfig.project = config.project;
+  }
+  if (config.application !== undefined && config.application !== "") {
+    newConfig.application = config.application;
+  }
+  if (config.env !== undefined && config.env !== "") {
+    newConfig.env = config.env;
+  }
+
+  // 写入配置文件
+  try {
+    fs.writeFileSync(configFile, JSON.stringify(newConfig, null, 2) + "\n", "utf8");
+    logger.info("配置已写入", { path: configFile });
+  } catch (error) {
+    throw new Error(`写入配置文件失败: ${error.message}`);
+  }
+
+  // 重新加载全局配置
+  reloadConfig();
+
+  // 构建返回消息
+  let result = `KE 配置已成功保存\n`;
+  result += `配置文件路径: ${configFile}\n\n`;
+  result += `当前配置:\n`;
+  result += `  domain: ${newConfig.domain || "(未设置)"}\n`;
+  result += `  access_token: ${newConfig.access_token ? "******(已设置)" : "(未设置)"}\n`;
+  result += `  tenant: ${newConfig.tenant || "(未设置)"}\n`;
+  result += `  project: ${newConfig.project || "(未设置)"}\n`;
+  result += `  application: ${newConfig.application || "(未设置)"}\n`;
+  result += `  env: ${newConfig.env || "(未设置)"}\n`;
+
+  return result;
+}
+
 /**
  * ke_app_restart - 重启 KE 应用（通过删除 Pod）
+ * @param {Object} options - 配置选项
+ * @param {string} options.domain - KE 平台域名，未指定时从配置文件获取
+ * @param {string} options.access_token - 访问令牌，未指定时从配置文件获取
+ * @param {string} options.tenant - 租户名称，未指定时从配置文件获取
+ * @param {string} options.project - 项目名称，未指定时从配置文件获取
+ * @param {string} options.application - 应用名称，未指定时从配置文件获取
+ * @param {string} options.env - 环境名称，未指定时从配置文件获取
  */
-async function keAppRestart() {
+async function keAppRestart(options = {}) {
   reloadConfig();
   
-  const application = getConfig("application");
-  const env = getConfig("env");
+  // 配置项优先从参数获取，未指定则从配置文件获取
+  const domain = options.domain || getConfig("domain");
+  const accessToken = options.access_token || getConfig("access_token");
+  const tenant = options.tenant || getConfig("tenant");
+  const project = options.project || getConfig("project");
+  const application = options.application || getConfig("application");
+  const env = options.env || getConfig("env");
   
-  if (!application || !env) {
-    throw new Error("配置项 application 或 env 未设置");
+  if (!tenant) {
+    throw new Error("参数 tenant 未指定且配置文件中未设置");
+  }
+  if (!project) {
+    throw new Error("参数 project 未指定且配置文件中未设置");
+  }
+  if (!application) {
+    throw new Error("参数 application 未指定且配置文件中未设置");
+  }
+  if (!env) {
+    throw new Error("参数 env 未指定且配置文件中未设置");
   }
 
-  const namespace = getTenantNamespace();
+  const namespace = `${tenant}-${project}`;
+  const requestOptions = { domain, access_token: accessToken };
   
   logger.info("重启应用", { application, env, namespace });
 
   // 1. 获取应用状态
   const statusUrl = `amp/v4/namespace/${namespace}/env/${env}/applications/${application}/appstatus/view?canary=false`;
-  const statusData = await keRequest("GET", statusUrl);
+  const statusData = await keRequest("GET", statusUrl, requestOptions);
 
   // 2. 提取 Pod 名称
   const podNames = [];
@@ -233,7 +349,7 @@ async function keAppRestart() {
   for (const podName of podNames) {
     try {
       const deleteUrl = `amp/v4/namespace/${namespace}/env/${env}/applications/${application}/pods/${podName}/delete?cluster=${env}`;
-      await keRequest("DELETE", deleteUrl);
+      await keRequest("DELETE", deleteUrl, requestOptions);
       deletedPods.push(podName);
       logger.info(`已删除 Pod: ${podName}`);
     } catch (error) {
@@ -268,17 +384,35 @@ async function keAppRestart() {
 
 /**
  * ke_pipeline_list - 获取流水线列表
+ * @param {Object} options - 配置选项
+ * @param {string} options.domain - KE 平台域名，未指定时从配置文件获取
+ * @param {string} options.access_token - 访问令牌，未指定时从配置文件获取
+ * @param {string} options.tenant - 租户名称，未指定时从配置文件获取
+ * @param {string} options.project - 项目名称，未指定时从配置文件获取
+ * @param {string} options.application - 应用名称（可选），未指定时从配置文件获取
+ * @param {number} options.page - 页码，默认 1
+ * @param {number} options.pageSize - 每页数量，默认 20
  */
-async function kePipelineList(page = 1, pageSize = 20) {
+async function kePipelineList(options = {}) {
   reloadConfig();
   
-  const domain = getConfig("domain");
-  const tenant = getConfig("tenant");
-  const project = getConfig("project");
-  const application = getConfig("application");
+  // 配置项优先从参数获取，未指定则从配置文件获取
+  const domain = options.domain || getConfig("domain");
+  const accessToken = options.access_token || getConfig("access_token");
+  const tenant = options.tenant || getConfig("tenant");
+  const project = options.project || getConfig("project");
+  const application = options.application || getConfig("application");
+  const page = options.page || 1;
+  const pageSize = options.pageSize || 20;
   
-  if (!tenant || !project) {
-    throw new Error("配置项 tenant 或 project 未设置");
+  if (!domain) {
+    throw new Error("参数 domain 未指定且配置文件中未设置");
+  }
+  if (!tenant) {
+    throw new Error("参数 tenant 未指定且配置文件中未设置");
+  }
+  if (!project) {
+    throw new Error("参数 project 未指定且配置文件中未设置");
   }
 
   // 构建 label 参数
@@ -298,7 +432,7 @@ async function kePipelineList(page = 1, pageSize = 20) {
   
   logger.info("获取流水线列表", { group, application });
   
-  const data = await keRequest("GET", url);
+  const data = await keRequest("GET", url, { domain, access_token: accessToken });
   const pipelinesData = data.rtnData?.data || [];
   const envMapping = data.rtnData?.env || {};
   const totalCount = data.rtnData?.count || 0;
@@ -334,17 +468,21 @@ async function kePipelineList(page = 1, pageSize = 20) {
 
 /**
  * ke_pipeline_info - 获取流水线信息
+ * @param {Object} options - 配置选项
+ * @param {string} options.access_token - 访问令牌，未指定时从配置文件获取
+ * @param {string} options.pipelineUrl - 流水线地址（必填）
  */
-async function kePipelineInfo(pipelineUrl) {
+async function kePipelineInfo(options = {}) {
   reloadConfig();
   
+  const accessToken = options.access_token || getConfig("access_token");
+  const pipelineUrl = options.pipelineUrl;
+  
   if (!pipelineUrl) {
     throw new Error("参数 pipelineUrl 不能为空");
   }
-  
-  const accessToken = getConfig("access_token");
   if (!accessToken) {
-    throw new Error("配置项 access_token 未设置");
+    throw new Error("参数 access_token 未指定且配置文件中未设置");
   }
 
   logger.info("获取流水线信息", { url: pipelineUrl });
@@ -393,17 +531,27 @@ async function kePipelineInfo(pipelineUrl) {
 
 /**
  * ke_pipeline_create - 执行流水线
+ * @param {Object} options - 配置选项
+ * @param {string} options.access_token - 访问令牌，未指定时从配置文件获取
+ * @param {string} options.pipelineUrl - 流水线地址（必填）
+ * @param {Object} options.globalArguments - 全局参数字典（必填）
+ * @param {number} options.deadline - 超时时间（秒），默认 86400
+ * @param {string} options.review - 审核信息，默认空
  */
-async function kePipelineCreate(pipelineUrl, globalArguments, deadline = 86400, review = "") {
+async function kePipelineCreate(options = {}) {
   reloadConfig();
   
+  const accessToken = options.access_token || getConfig("access_token");
+  const pipelineUrl = options.pipelineUrl;
+  const globalArguments = options.globalArguments;
+  const deadline = options.deadline || 86400;
+  const review = options.review || "";
+  
   if (!pipelineUrl) {
     throw new Error("参数 pipelineUrl 不能为空");
   }
-  
-  const accessToken = getConfig("access_token");
   if (!accessToken) {
-    throw new Error("配置项 access_token 未设置");
+    throw new Error("参数 access_token 未指定且配置文件中未设置");
   }
   if (!globalArguments || Object.keys(globalArguments).length === 0) {
     throw new Error("参数 globalArguments 不能为空");
@@ -454,12 +602,18 @@ async function kePipelineCreate(pipelineUrl, globalArguments, deadline = 86400,
 
 /**
  * ke_tenants_list - 列出所有租户
+ * @param {Object} options - 配置选项
+ * @param {string} options.domain - KE 平台域名，未指定时从配置文件获取
+ * @param {string} options.access_token - 访问令牌，未指定时从配置文件获取
  */
-async function keTenantsList() {
+async function keTenantsList(options = {}) {
   reloadConfig();
   
+  const domain = options.domain || getConfig("domain");
+  const accessToken = options.access_token || getConfig("access_token");
+  
   const url = "user-center/v4/tenants/list?page=1&pageSize=100&type=all&single=true";
-  const data = await keRequest("GET", url);
+  const data = await keRequest("GET", url, { domain, access_token: accessToken });
 
   const tenantsData = data.rtnData?.data || [];
   
@@ -480,17 +634,24 @@ async function keTenantsList() {
 
 /**
  * ke_projects_list - 列出所有项目
+ * @param {Object} options - 配置选项
+ * @param {string} options.domain - KE 平台域名，未指定时从配置文件获取
+ * @param {string} options.access_token - 访问令牌，未指定时从配置文件获取
+ * @param {string} options.tenant - 租户名称，未指定时从配置文件获取
  */
-async function keProjectsList() {
+async function keProjectsList(options = {}) {
   reloadConfig();
   
-  const tenant = getConfig("tenant");
+  const domain = options.domain || getConfig("domain");
+  const accessToken = options.access_token || getConfig("access_token");
+  const tenant = options.tenant || getConfig("tenant");
+  
   if (!tenant) {
-    throw new Error("配置项 tenant 未设置");
+    throw new Error("参数 tenant 未指定且配置文件中未设置");
   }
 
   const url = `user-center/v4/tenants/${tenant}/projects/list`;
-  const data = await keRequest("GET", url);
+  const data = await keRequest("GET", url, { domain, access_token: accessToken });
 
   const projectsData = data.rtnData?.data || [];
   
@@ -513,13 +674,30 @@ async function keProjectsList() {
 
 /**
  * ke_app_list - 列出所有应用
+ * @param {Object} options - 配置选项
+ * @param {string} options.domain - KE 平台域名，未指定时从配置文件获取
+ * @param {string} options.access_token - 访问令牌，未指定时从配置文件获取
+ * @param {string} options.tenant - 租户名称，未指定时从配置文件获取
+ * @param {string} options.project - 项目名称，未指定时从配置文件获取
  */
-async function keAppList() {
+async function keAppList(options = {}) {
   reloadConfig();
   
-  const namespace = getTenantNamespace();
+  const domain = options.domain || getConfig("domain");
+  const accessToken = options.access_token || getConfig("access_token");
+  const tenant = options.tenant || getConfig("tenant");
+  const project = options.project || getConfig("project");
+  
+  if (!tenant) {
+    throw new Error("参数 tenant 未指定且配置文件中未设置");
+  }
+  if (!project) {
+    throw new Error("参数 project 未指定且配置文件中未设置");
+  }
+
+  const namespace = `${tenant}-${project}`;
   const url = `amp/v4/namespace/${namespace}/applications/list?page=1&pageSize=999`;
-  const data = await keRequest("GET", url);
+  const data = await keRequest("GET", url, { domain, access_token: accessToken });
 
   const appsData = data.rtnData?.data || [];
   
@@ -540,17 +718,24 @@ async function keAppList() {
 
 /**
  * ke_env_list - 获取环境列表
+ * @param {Object} options - 配置选项
+ * @param {string} options.domain - KE 平台域名，未指定时从配置文件获取
+ * @param {string} options.access_token - 访问令牌，未指定时从配置文件获取
+ * @param {string} options.tenant - 租户名称，未指定时从配置文件获取
  */
-async function keEnvList() {
+async function keEnvList(options = {}) {
   reloadConfig();
   
-  const tenant = getConfig("tenant");
+  const domain = options.domain || getConfig("domain");
+  const accessToken = options.access_token || getConfig("access_token");
+  const tenant = options.tenant || getConfig("tenant");
+  
   if (!tenant) {
-    throw new Error("配置项 tenant 未设置");
+    throw new Error("参数 tenant 未指定且配置文件中未设置");
   }
 
   const url = `user-center/v4/tenants/${tenant}/clusters/all/list`;
-  const data = await keRequest("GET", url);
+  const data = await keRequest("GET", url, { domain, access_token: accessToken });
 
   const clustersData = data.rtnData?.data || [];
   const envList = clustersData.map(c => c.name).filter(Boolean);
@@ -570,23 +755,40 @@ async function keEnvList() {
 
 /**
  * ke_pods_list - 获取 Pod 列表
+ * @param {Object} options - 配置选项
+ * @param {string} options.domain - KE 平台域名，未指定时从配置文件获取
+ * @param {string} options.access_token - 访问令牌，未指定时从配置文件获取
+ * @param {string} options.tenant - 租户名称，未指定时从配置文件获取
+ * @param {string} options.project - 项目名称，未指定时从配置文件获取
+ * @param {string} options.appName - 应用名称（必填）
+ * @param {string} options.env - 环境名称（必填）
  */
-async function kePodsList(appName) {
+async function kePodsList(options = {}) {
   reloadConfig();
   
+  const domain = options.domain || getConfig("domain");
+  const accessToken = options.access_token || getConfig("access_token");
+  const tenant = options.tenant || getConfig("tenant");
+  const project = options.project || getConfig("project");
+  const appName = options.appName;
+  const env = options.env;
+  
+  if (!tenant) {
+    throw new Error("参数 tenant 未指定且配置文件中未设置");
+  }
+  if (!project) {
+    throw new Error("参数 project 未指定且配置文件中未设置");
+  }
   if (!appName) {
     throw new Error("参数 appName 不能为空");
   }
-
-  const namespace = getTenantNamespace();
-  const env = getConfig("env");
-  
   if (!env) {
-    throw new Error("配置项 env 未设置");
+    throw new Error("参数 env 不能为空");
   }
 
+  const namespace = `${tenant}-${project}`;
   const url = `amp/v4/namespace/${namespace}/env/${env}/applications/${appName}/appstatus/view?canary=false`;
-  const data = await keRequest("GET", url);
+  const data = await keRequest("GET", url, { domain, access_token: accessToken });
 
   // 提取 Pod 列表
   const podsList = [];
@@ -634,20 +836,42 @@ async function kePodsList(appName) {
 
 /**
  * ke_pod_log_list - 获取 Pod 日志列表
+ * @param {Object} options - 配置选项
+ * @param {string} options.domain - KE 平台域名，未指定时从配置文件获取
+ * @param {string} options.access_token - 访问令牌，未指定时从配置文件获取
+ * @param {string} options.tenant - 租户名称，未指定时从配置文件获取
+ * @param {string} options.namespace - 命名空间（必填）
+ * @param {string} options.service - 服务名称（必填）
+ * @param {string} options.env - 环境名称（必填）
+ * @param {number} options.startTime - 开始时间（纳秒时间戳，必填）
+ * @param {number} options.endTime - 结束时间（纳秒时间戳，必填）
+ * @param {number} options.size - 返回记录数量，默认 100
+ * @param {number} options.offset - 偏移量，默认 0
+ * @param {string} options.sort - 排序方式，默认 desc
  */
-async function kePodLogList(namespace, service, env, startTime, endTime, size = 100, offset = 0, sort = "desc") {
+async function kePodLogList(options = {}) {
   reloadConfig();
   
+  const domain = options.domain || getConfig("domain");
+  const accessToken = options.access_token || getConfig("access_token");
+  const tenant = options.tenant || getConfig("tenant");
+  const namespace = options.namespace;
+  const service = options.service;
+  const env = options.env;
+  const startTime = options.startTime;
+  const endTime = options.endTime;
+  const size = options.size || 100;
+  const offset = options.offset || 0;
+  const sort = options.sort || "desc";
+  
+  if (!tenant) {
+    throw new Error("参数 tenant 未指定且配置文件中未设置");
+  }
   if (!namespace) throw new Error("参数 namespace 不能为空");
   if (!service) throw new Error("参数 service 不能为空");
   if (!env) throw new Error("参数 env 不能为空");
-  if (!startTime) throw new Error("参数 start_time 不能为空");
-  if (!endTime) throw new Error("参数 end_time 不能为空");
-
-  const tenant = getConfig("tenant");
-  if (!tenant) {
-    throw new Error("配置项 tenant 未设置");
-  }
+  if (!startTime) throw new Error("参数 startTime 不能为空");
+  if (!endTime) throw new Error("参数 endTime 不能为空");
 
   const url = `armilla/v1/group/${tenant}/env/${env}/log/list`;
   
@@ -679,7 +903,7 @@ async function kePodLogList(namespace, service, env, startTime, endTime, size =
     log_version: "v3"
   };
 
-  const data = await keRequest("POST", url, { body: requestBody });
+  const data = await keRequest("POST", url, { domain, access_token: accessToken, body: requestBody });
   const records = data.rtnData?.records || [];
 
   if (records.length === 0) {
@@ -718,106 +942,6 @@ async function kePodLogList(namespace, service, env, startTime, endTime, size =
   return result;
 }
 
-/**
- * ke_pod_exec - 在 Pod 容器中执行命令
- */
-async function kePodExec(tenant, project, podName, cluster, command, container = "", nodeName = "") {
-  reloadConfig();
-  
-  if (!tenant) throw new Error("参数 tenant 不能为空");
-  if (!project) throw new Error("参数 project 不能为空");
-  if (!podName) throw new Error("参数 podName 不能为空");
-  if (!cluster) throw new Error("参数 cluster 不能为空");
-  if (!command) throw new Error("参数 command 不能为空");
-
-  const namespace = `${tenant}-${project}`;
-  
-  // 构建 exec API URL
-  // 根据 KE 平台的 API 结构，exec 接口可能在 amp/v4 下
-  const url = `amp/v4/namespace/${namespace}/env/${cluster}/pods/${podName}/exec`;
-  
-  logger.info("执行 Pod 命令", { namespace, podName, cluster, command, container, nodeName });
-
-  const requestBody = {
-    command: command.split(/\s+/), // 将命令字符串拆分为数组
-    container: container || undefined,
-    nodeName: nodeName || undefined
-  };
-
-  // 移除 undefined 字段
-  Object.keys(requestBody).forEach(key => {
-    if (requestBody[key] === undefined) {
-      delete requestBody[key];
-    }
-  });
-
-  try {
-    const data = await keRequest("POST", url, { body: requestBody });
-    
-    const execResult = data.rtnData || {};
-    const stdout = execResult.stdout || "";
-    const stderr = execResult.stderr || "";
-    const exitCode = execResult.exitCode !== undefined ? execResult.exitCode : (data.rtnCode === "000000" ? 0 : 1);
-
-    let result = `命令执行完成\n`;
-    result += `Pod: ${podName}\n`;
-    result += `命名空间: ${namespace}\n`;
-    result += `环境: ${cluster}\n`;
-    result += `命令: ${command}\n`;
-    result += `退出码: ${exitCode}\n\n`;
-
-    if (stdout) {
-      result += `标准输出:\n${stdout}\n`;
-    }
-
-    if (stderr) {
-      result += `错误输出:\n${stderr}\n`;
-    }
-
-    if (!stdout && !stderr) {
-      result += `(无输出)`;
-    }
-
-    return result;
-  } catch (error) {
-    // 如果 POST 失败，尝试 GET 方式（某些平台可能使用 GET）
-    logger.debug("POST 方式失败，尝试 GET 方式", { error: error.message });
-    
-    const getUrl = `${url}?command=${encodeURIComponent(command)}${container ? `&container=${encodeURIComponent(container)}` : ''}${nodeName ? `&nodeName=${encodeURIComponent(nodeName)}` : ''}`;
-    
-    try {
-      const data = await keRequest("GET", getUrl);
-      const execResult = data.rtnData || {};
-      const stdout = execResult.stdout || "";
-      const stderr = execResult.stderr || "";
-      const exitCode = execResult.exitCode !== undefined ? execResult.exitCode : 0;
-
-      let result = `命令执行完成\n`;
-      result += `Pod: ${podName}\n`;
-      result += `命名空间: ${namespace}\n`;
-      result += `环境: ${cluster}\n`;
-      result += `命令: ${command}\n`;
-      result += `退出码: ${exitCode}\n\n`;
-
-      if (stdout) {
-        result += `标准输出:\n${stdout}\n`;
-      }
-
-      if (stderr) {
-        result += `错误输出:\n${stderr}\n`;
-      }
-
-      if (!stdout && !stderr) {
-        result += `(无输出)`;
-      }
-
-      return result;
-    } catch (getError) {
-      throw new Error(`执行命令失败: ${error.message}。如果 KE 平台不支持 exec API，请使用 webshell 手动操作。`);
-    }
-  }
-}
-
 // ==================== MCP 服务器 ====================
 
 const server = new McpServer({
@@ -825,16 +949,48 @@ const server = new McpServer({
   version: VERSION
 });
 
+// 注册工具：ke_config_reset
+server.registerTool(
+  "ke_config_reset",
+  {
+    description: "重置/更新 KE MCP 配置参数，配置后其他工具可自动读取这些默认值。",
+    inputSchema: {
+      domain: z.string().optional().describe("KE 平台域名（如：https://ke.example.com）。【必须】由用户手动输入，这是访问 KE 平台的基础地址，不可自动猜测"),
+      access_token: z.string().optional().describe("访问令牌（leo-user-token）。【必须】由用户手动输入，可从 KE 平台的用户设置中获取，不可自动猜测"),
+      tenant: z.string().optional().describe("租户名称。可通过 ke_tenants_list 工具获取可用租户列表，如果存在多个租户【必须】展示列表并让用户明确选择，不可自动选择"),
+      project: z.string().optional().describe("项目名称。可通过 ke_projects_list 工具获取指定租户下的项目列表，如果存在多个项目【必须】展示列表并让用户明确选择，不可自动选择"),
+      application: z.string().optional().describe("应用名称。可通过 ke_app_list 工具获取指定租户和项目下的应用列表，如果存在多个应用【必须】展示列表并让用户明确选择，不可自动选择"),
+      env: z.string().optional().describe("环境名称（如：test、prod）。可通过 ke_env_list 工具获取指定租户下的环境列表，如果存在多个环境【必须】展示列表并让用户明确选择，不可自动选择")
+    }
+  },
+  async ({ domain, access_token, tenant, project, application, env }) => {
+    try {
+      const result = await keConfigReset({ domain, access_token, tenant, project, application, env });
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      logger.error("ke_config_reset 失败", { error: error.message });
+      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
+    }
+  }
+);
+
 // 注册工具：ke_app_restart
 server.registerTool(
   "ke_app_restart",
   {
-    description: "重启 KE 应用（通过删除 Pod 触发自动重建）",
-    inputSchema: {}
+    description: "重启 KE 应用（通过删除 Pod 触发自动重建）。所有配置项如果未指定，则默认从项目目录下的 .mcp/bd-ke-mcp.json 配置文件中获取。",
+    inputSchema: {
+      domain: z.string().optional().describe("KE 平台域名（如：https://ke.example.com），用于 API 请求。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      access_token: z.string().optional().describe("访问令牌（leo-user-token），用于 API 认证。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      tenant: z.string().optional().describe("租户名称，用于构建命名空间。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      project: z.string().optional().describe("项目名称，用于构建命名空间。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      application: z.string().optional().describe("要重启的应用名称。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      env: z.string().optional().describe("环境名称（如：production、development），指定要重启的环境。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取")
+    }
   },
-  async () => {
+  async ({ domain, access_token, tenant, project, application, env }) => {
     try {
-      const result = await keAppRestart();
+      const result = await keAppRestart({ domain, access_token, tenant, project, application, env });
       return { content: [{ type: "text", text: result }] };
     } catch (error) {
       logger.error("ke_app_restart 失败", { error: error.message });
@@ -847,15 +1003,20 @@ server.registerTool(
 server.registerTool(
   "ke_pipeline_list",
   {
-    description: "获取 KE 流水线列表，根据配置文件中的 tenant、project、application 筛选",
+    description: "获取 KE 流水线列表，根据 tenant、project、application 筛选。所有配置项如果未指定，则默认从项目目录下的 .mcp/bd-ke-mcp.json 配置文件中获取。",
     inputSchema: {
-      page: z.number().optional().default(1).describe("页码，默认 1"),
-      pageSize: z.number().optional().default(20).describe("每页数量，默认 20")
+      domain: z.string().optional().describe("KE 平台域名（如：https://ke.example.com），用于 API 请求和构建流水线访问地址。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      access_token: z.string().optional().describe("访问令牌（leo-user-token），用于 API 认证。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      tenant: z.string().optional().describe("租户名称，用于筛选流水线。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      project: z.string().optional().describe("项目名称，用于筛选流水线。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      application: z.string().optional().describe("应用名称，用于进一步筛选特定应用的流水线。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取，可为空表示不按应用筛选"),
+      page: z.number().optional().default(1).describe("分页页码，从 1 开始，默认为 1"),
+      pageSize: z.number().optional().default(20).describe("每页返回的流水线数量，默认为 20")
     }
   },
-  async ({ page, pageSize }) => {
+  async ({ domain, access_token, tenant, project, application, page, pageSize }) => {
     try {
-      const result = await kePipelineList(page, pageSize);
+      const result = await kePipelineList({ domain, access_token, tenant, project, application, page, pageSize });
       return { content: [{ type: "text", text: result }] };
     } catch (error) {
       logger.error("ke_pipeline_list 失败", { error: error.message });
@@ -868,14 +1029,15 @@ server.registerTool(
 server.registerTool(
   "ke_pipeline_info",
   {
-    description: "获取 KE 流水线信息，包括流水线名称和执行参数",
+    description: "获取 KE 流水线信息，包括流水线名称和执行参数。access_token 如果未指定，则默认从项目目录下的 .mcp/bd-ke-mcp.json 配置文件中获取。",
     inputSchema: {
-      pipelineUrl: z.string().describe("流水线地址（如：http://pro.kubeease.cn/pipeline/v1/group/tenant-project/pipelines/app-xxx/view）")
+      access_token: z.string().optional().describe("访问令牌（leo-user-token），用于 API 认证。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      pipelineUrl: z.string().describe("流水线地址，完整的 URL 路径（如：https://ke.example.com/pipeline/v1/group/tenant-project/pipelines/app-xxx/view），可从 ke_pipeline_list 获取")
     }
   },
-  async ({ pipelineUrl }) => {
+  async ({ access_token, pipelineUrl }) => {
     try {
-      const result = await kePipelineInfo(pipelineUrl);
+      const result = await kePipelineInfo({ access_token, pipelineUrl });
       return { content: [{ type: "text", text: result }] };
     } catch (error) {
       logger.error("ke_pipeline_info 失败", { error: error.message });
@@ -888,17 +1050,18 @@ server.registerTool(
 server.registerTool(
   "ke_pipeline_create",
   {
-    description: "执行 KE 流水线（创建流水线运行时）",
+    description: "执行 KE 流水线（创建流水线运行时）。access_token 如果未指定，则默认从项目目录下的 .mcp/bd-ke-mcp.json 配置文件中获取。",
     inputSchema: {
-      pipelineUrl: z.string().describe("流水线地址（如：http://pro.kubeease.cn/pipeline/v1/group/tenant-project/pipelines/app-xxx/view）"),
-      globalArguments: z.record(z.string()).describe("全局参数字典，键为参数名，值为参数值"),
-      deadline: z.number().optional().default(86400).describe("超时时间（秒），默认 86400"),
-      review: z.string().optional().default("").describe("审核信息")
+      access_token: z.string().optional().describe("访问令牌（leo-user-token），用于 API 认证。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      pipelineUrl: z.string().describe("流水线地址，完整的 URL 路径（如：https://ke.example.com/pipeline/v1/group/tenant-project/pipelines/app-xxx/view），可从 ke_pipeline_list 获取"),
+      globalArguments: z.record(z.string()).describe("全局参数字典，键为参数名，值为参数值。参数列表可通过 ke_pipeline_info 获取"),
+      deadline: z.number().optional().default(86400).describe("流水线执行超时时间（秒），超过此时间流水线将被终止，默认 86400（24小时）"),
+      review: z.string().optional().default("").describe("审核信息，可选的审核备注或说明")
     }
   },
-  async ({ pipelineUrl, globalArguments, deadline, review }) => {
+  async ({ access_token, pipelineUrl, globalArguments, deadline, review }) => {
     try {
-      const result = await kePipelineCreate(pipelineUrl, globalArguments, deadline, review);
+      const result = await kePipelineCreate({ access_token, pipelineUrl, globalArguments, deadline, review });
       return { content: [{ type: "text", text: result }] };
     } catch (error) {
       logger.error("ke_pipeline_create 失败", { error: error.message });
@@ -911,12 +1074,15 @@ server.registerTool(
 server.registerTool(
   "ke_tenants_list",
   {
-    description: "列出所有的租户",
-    inputSchema: {}
+    description: "列出当前用户有权限访问的所有租户。所有配置项如果未指定，则默认从项目目录下的 .mcp/bd-ke-mcp.json 配置文件中获取。",
+    inputSchema: {
+      domain: z.string().optional().describe("KE 平台域名（如：https://ke.example.com），用于 API 请求。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      access_token: z.string().optional().describe("访问令牌（leo-user-token），用于 API 认证。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取")
+    }
   },
-  async () => {
+  async ({ domain, access_token }) => {
     try {
-      const result = await keTenantsList();
+      const result = await keTenantsList({ domain, access_token });
       return { content: [{ type: "text", text: result }] };
     } catch (error) {
       logger.error("ke_tenants_list 失败", { error: error.message });
@@ -929,12 +1095,16 @@ server.registerTool(
 server.registerTool(
   "ke_projects_list",
   {
-    description: "列出所有的项目",
-    inputSchema: {}
+    description: "列出指定租户下的所有项目。所有配置项如果未指定，则默认从项目目录下的 .mcp/bd-ke-mcp.json 配置文件中获取。",
+    inputSchema: {
+      domain: z.string().optional().describe("KE 平台域名（如：https://ke.example.com），用于 API 请求。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      access_token: z.string().optional().describe("访问令牌（leo-user-token），用于 API 认证。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      tenant: z.string().optional().describe("租户名称，指定要查询项目的租户。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取")
+    }
   },
-  async () => {
+  async ({ domain, access_token, tenant }) => {
     try {
-      const result = await keProjectsList();
+      const result = await keProjectsList({ domain, access_token, tenant });
       return { content: [{ type: "text", text: result }] };
     } catch (error) {
       logger.error("ke_projects_list 失败", { error: error.message });
@@ -947,12 +1117,17 @@ server.registerTool(
 server.registerTool(
   "ke_app_list",
   {
-    description: "列出所有的应用",
-    inputSchema: {}
+    description: "列出指定租户和项目下的所有应用。所有配置项如果未指定，则默认从项目目录下的 .mcp/bd-ke-mcp.json 配置文件中获取。",
+    inputSchema: {
+      domain: z.string().optional().describe("KE 平台域名（如：https://ke.example.com），用于 API 请求。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      access_token: z.string().optional().describe("访问令牌（leo-user-token），用于 API 认证。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      tenant: z.string().optional().describe("租户名称，用于构建命名空间。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      project: z.string().optional().describe("项目名称，用于构建命名空间。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取")
+    }
   },
-  async () => {
+  async ({ domain, access_token, tenant, project }) => {
     try {
-      const result = await keAppList();
+      const result = await keAppList({ domain, access_token, tenant, project });
       return { content: [{ type: "text", text: result }] };
     } catch (error) {
       logger.error("ke_app_list 失败", { error: error.message });
@@ -965,14 +1140,16 @@ server.registerTool(
 server.registerTool(
   "ke_env_list",
   {
-    description: "获取当前租户下的所有环境列表",
+    description: "获取指定租户下的所有可用环境（集群）列表。所有配置项如果未指定，则默认从项目目录下的 .mcp/bd-ke-mcp.json 配置文件中获取。",
     inputSchema: {
-      projectName: z.string().optional().describe("项目名称（已废弃，保留以保持向后兼容）")
+      domain: z.string().optional().describe("KE 平台域名（如：https://ke.example.com），用于 API 请求。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      access_token: z.string().optional().describe("访问令牌（leo-user-token），用于 API 认证。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      tenant: z.string().optional().describe("租户名称，指定要查询环境的租户。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取")
     }
   },
-  async () => {
+  async ({ domain, access_token, tenant }) => {
     try {
-      const result = await keEnvList();
+      const result = await keEnvList({ domain, access_token, tenant });
       return { content: [{ type: "text", text: result }] };
     } catch (error) {
       logger.error("ke_env_list 失败", { error: error.message });
@@ -985,14 +1162,19 @@ server.registerTool(
 server.registerTool(
   "ke_pods_list",
   {
-    description: "获取指定应用的 Pod 实例列表，包含实例名称、状态、创建时间、容器IP、运行节点、重启次数等信息",
+    description: "获取指定应用的 Pod 实例列表，包含实例名称、状态、创建时间、容器IP、运行节点、重启次数等信息。所有配置项如果未指定，则默认从项目目录下的 .mcp/bd-ke-mcp.json 配置文件中获取。",
     inputSchema: {
-      appName: z.string().describe("应用名称，可通过 ke_app_list 获取")
+      domain: z.string().optional().describe("KE 平台域名（如：https://ke.example.com），用于 API 请求。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      access_token: z.string().optional().describe("访问令牌（leo-user-token），用于 API 认证。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      tenant: z.string().optional().describe("租户名称，用于构建命名空间。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      project: z.string().optional().describe("项目名称，用于构建命名空间。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      appName: z.string().describe("应用名称，指定要查询 Pod 的应用，可通过 ke_app_list 获取"),
+      env: z.string().describe("环境名称，指定要查询的环境（集群），可通过 ke_env_list 获取")
     }
   },
-  async ({ appName }) => {
+  async ({ domain, access_token, tenant, project, appName, env }) => {
     try {
-      const result = await kePodsList(appName);
+      const result = await kePodsList({ domain, access_token, tenant, project, appName, env });
       return { content: [{ type: "text", text: result }] };
     } catch (error) {
       logger.error("ke_pods_list 失败", { error: error.message });
@@ -1005,21 +1187,24 @@ server.registerTool(
 server.registerTool(
   "ke_pod_log_list",
   {
-    description: "获取指定应用的 Pod 日志列表",
+    description: "获取指定应用的 Pod 日志列表，支持按时间范围查询和分页。所有配置项如果未指定，则默认从项目目录下的 .mcp/bd-ke-mcp.json 配置文件中获取。",
     inputSchema: {
-      namespace: z.string().describe("命名空间，格式为 tenant-project（如：app-sheyang）"),
-      service: z.string().describe("服务名称（应用名称），可通过 ke_app_list 获取"),
-      env: z.string().describe("环境名称，可通过 ke_env_list 获取"),
-      start_time: z.number().describe("开始时间（纳秒时间戳）"),
-      end_time: z.number().describe("结束时间（纳秒时间戳）"),
-      size: z.number().optional().default(100).describe("返回记录数量，默认 100"),
-      offset: z.number().optional().default(0).describe("偏移量，默认 0"),
-      sort: z.string().optional().default("desc").describe("排序方式，默认 desc（降序），可选 asc（升序）")
+      domain: z.string().optional().describe("KE 平台域名（如：https://ke.example.com），用于 API 请求。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      access_token: z.string().optional().describe("访问令牌（leo-user-token），用于 API 认证。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      tenant: z.string().optional().describe("租户名称，用于日志查询 API 路径。未指定时从 .mcp/bd-ke-mcp.json 配置文件获取"),
+      namespace: z.string().describe("命名空间，格式为 tenant-project（如：myapp-production），用于筛选日志来源"),
+      service: z.string().describe("服务名称（即应用名称），指定要查询日志的应用，可通过 ke_app_list 获取"),
+      env: z.string().describe("环境名称，指定要查询日志的环境（集群），可通过 ke_env_list 获取"),
+      startTime: z.number().describe("查询开始时间，纳秒级时间戳（如：1704067200000000000 表示 2024-01-01 00:00:00）"),
+      endTime: z.number().describe("查询结束时间，纳秒级时间戳（如：1704153600000000000 表示 2024-01-02 00:00:00）"),
+      size: z.number().optional().default(100).describe("返回的日志记录数量，默认 100 条，建议不超过 1000"),
+      offset: z.number().optional().default(0).describe("分页偏移量，用于翻页查询，默认从 0 开始"),
+      sort: z.string().optional().default("desc").describe("日志排序方式，desc 表示按时间降序（最新在前，默认），asc 表示按时间升序（最早在前）")
     }
   },
-  async ({ namespace, service, env, start_time, end_time, size, offset, sort }) => {
+  async ({ domain, access_token, tenant, namespace, service, env, startTime, endTime, size, offset, sort }) => {
     try {
-      const result = await kePodLogList(namespace, service, env, start_time, end_time, size, offset, sort);
+      const result = await kePodLogList({ domain, access_token, tenant, namespace, service, env, startTime, endTime, size, offset, sort });
       return { content: [{ type: "text", text: result }] };
     } catch (error) {
       logger.error("ke_pod_log_list 失败", { error: error.message });
@@ -1028,32 +1213,6 @@ server.registerTool(
   }
 );
 
-// 注册工具：ke_pod_exec
-server.registerTool(
-  "ke_pod_exec",
-  {
-    description: "在 Pod 容器中执行命令（如：ls, pwd, cat 等）",
-    inputSchema: {
-      tenant: z.string().describe("租户名称"),
-      project: z.string().describe("项目名称"),
-      podName: z.string().describe("Pod 名称"),
-      cluster: z.string().describe("集群/环境名称（如：funeng-test）"),
-      command: z.string().describe("要执行的命令（如：ls, pwd, cat /etc/hosts）"),
-      container: z.string().optional().describe("容器名称（可选，如果 Pod 有多个容器）"),
-      nodeName: z.string().optional().describe("节点名称（可选）")
-    }
-  },
-  async ({ tenant, project, podName, cluster, command, container, nodeName }) => {
-    try {
-      const result = await kePodExec(tenant, project, podName, cluster, command, container, nodeName);
-      return { content: [{ type: "text", text: result }] };
-    } catch (error) {
-      logger.error("ke_pod_exec 失败", { error: error.message });
-      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
-    }
-  }
-);
-
 // ==================== 启动服务 ====================
 
 async function main() {
@@ -1067,6 +1226,7 @@ async function main() {
     pid: process.pid,
     projectRoot: getProjectRoot(),
     tools: [
+      "ke_config_reset",
       "ke_app_restart",
       "ke_pipeline_list",
       "ke_pipeline_info",
@@ -1076,8 +1236,7 @@ async function main() {
       "ke_app_list",
       "ke_env_list",
       "ke_pods_list",
-      "ke_pod_log_list",
-      "ke_pod_exec"
+      "ke_pod_log_list"
     ]
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junjun-org/bd-ke-mcp",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "type": "module",
   "description": "MCP (Model Context Protocol) tools for BD-KE - Knowledge Engine application management",
   "main": "index.js",