@junjun-org/bd-ke-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 章文俊
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,284 @@
+# BD-KE MCP Server
+
+这是一个符合 MCP (Model Context Protocol) 规范的 Node.js 服务器，用于管理 KE (Knowledge Engine) 应用。
+
+## 快速开始
+
+### 1. 安装
+
+**使用 npx（推荐）：**
+
+```bash
+npx bd-ke-mcp
+```
+
+**全局安装：**
+
+```bash
+npm install -g bd-ke-mcp
+```
+
+**本地开发：**
+
+```bash
+cd /path/to/bd-ke-mcp
+npm install
+```
+
+### 2. 配置 Cursor
+
+在 Cursor 的 MCP 配置文件中添加：
+
+**使用 npx（推荐）：**
+
+```json
+{
+  "mcpServers": {
+    "bd-ke-mcp": {
+      "command": "npx",
+      "args": ["-y", "bd-ke-mcp"],
+      "env": {
+        "PROJECT_ROOT": "${workspaceFolder}"
+      }
+    }
+  }
+}
+```
+
+**本地开发模式：**
+
+```json
+{
+  "mcpServers": {
+    "bd-ke-mcp": {
+      "command": "node",
+      "args": ["/path/to/bd-ke-mcp/index.js"],
+      "env": {
+        "PROJECT_ROOT": "${workspaceFolder}"
+      }
+    }
+  }
+}
+```
+
+配置文件位置：
+- 通过 Cursor 设置界面：Settings → Features → Model Context Protocol
+
+### 3. 配置项目
+
+在项目根目录创建 `.mcp/bd-ke-mcp.json`：
+
+```json
+{
+  "domain": "https://ke.example.com",
+  "access_token": "your_access_token_here",
+  "tenant": "your_tenant",
+  "project": "your_project",
+  "application": "your_application",
+  "env": "production"
+}
+```
+
+**注意：**
+- 配置采用扁平化结构，所有配置项直接放在顶层
+- 配置文件包含敏感信息，建议添加到 `.gitignore`
+- 可通过环境变量覆盖配置（使用 `BD_KE_MCP_` 前缀）
+
+### 4. 使用
+
+配置完成后，重启 Cursor。MCP 服务器会自动启动，可以在 Cursor 中使用以下工具。
+
+## 项目结构
+
+```
+bd-ke-mcp/
+├── index.js             # MCP服务器主文件（包含所有工具实现）
+├── package.json         # 项目配置文件
+├── .mcp/               # 配置目录
+│   └── bd-ke-mcp.json.example  # 配置示例
+├── README.md           # 项目说明文档
+└── LICENSE             # 许可证
+```
+
+## 配置说明
+
+### 配置文件位置
+
+`.mcp/bd-ke-mcp.json` - 项目根目录下的 `.mcp` 目录
+
+### 配置项
+
+| 配置项 | 类型 | 必需 | 描述 |
+|--------|------|------|------|
+| `domain` | string | 是 | KE服务地址 |
+| `access_token` | string | 是 | 授权token |
+| `tenant` | string | 是 | 租户名称 |
+| `project` | string | 是 | 项目名称 |
+| `application` | string | 是 | 应用名称 |
+| `env` | string | 是 | 环境（如：development, staging, production） |
+
+**配置说明：**
+- `tenant` 和 `project` 组合后形成 KE 的命名空间（namespace），格式为 `tenant-project`
+- 例如：`tenant=app`, `project=xxx`，则实际的命名空间为 `app-xxx`
+- 在 KE API 调用中，URL 路径中的 `namespace` 参数使用的是 `tenant-project` 格式
+
+### 环境变量
+
+配置可通过环境变量设置（优先级高于配置文件）：
+
+```bash
+export BD_KE_MCP_DOMAIN="https://ke.example.com"
+export BD_KE_MCP_ACCESS_TOKEN="your_access_token"
+export BD_KE_MCP_TENANT="your_tenant"
+export BD_KE_MCP_PROJECT="your_project"
+export BD_KE_MCP_APPLICATION="your_application"
+export BD_KE_MCP_ENV="production"
+```
+
+环境变量命名规则：
+- 使用 `BD_KE_MCP_` 前缀
+- 配置键全部大写：`BD_KE_MCP_DOMAIN` → `domain`
+
+### 配置查找逻辑
+
+1. 从 `PROJECT_ROOT` 环境变量获取项目根目录
+2. 在项目根目录查找 `.mcp/bd-ke-mcp.json`
+3. 加载配置文件后，用环境变量覆盖同名配置
+
+## 可用工具
+
+### ke_app_restart
+
+重启 KE 应用（通过删除 Pod 触发自动重建）。
+
+**使用方式：**
+
+在 Cursor 中直接调用，无需参数。工具会自动从项目配置中读取应用信息。
+
+### ke_pipeline_info
+
+获取 KE 流水线信息，包括流水线名称和执行参数。
+
+**使用方式：**
+
+在 Cursor 中直接调用，无需参数。工具会从项目配置中读取流水线地址和授权token，返回流水线名称和可修改的执行参数。
+
+### ke_pipeline_create
+
+执行 KE 流水线（创建流水线运行时）。
+
+**使用方式：**
+
+在 Cursor 中调用，需要传入 `globalArguments` 参数（参数字典）。工具会从项目配置中读取流水线地址和授权token，执行流水线。
+
+**参数：**
+- `globalArguments` (必需): 全局参数字典，键为参数名，值为参数值
+- `deadline` (可选): 超时时间（秒），默认 86400
+- `review` (可选): 审核信息，默认为空字符串
+
+### ke_tenants_list
+
+列出所有的租户。
+
+### ke_projects_list
+
+列出所有的项目。
+
+### ke_app_list
+
+列出所有的应用。
+
+### ke_env_list
+
+获取当前租户下的所有环境列表。
+
+**参数：**
+- `projectName` (可选): 已废弃，保留以保持向后兼容，实际不使用此参数
+
+### ke_pods_list
+
+获取指定应用的Pod实例列表。
+
+**参数：**
+- `appName` (必需): 应用名称，可通过 `ke_app_list` 获取
+
+**返回信息：**
+- 实例名称
+- 实例状态（Running、Pending 等）
+- 创建时间
+- 容器IP
+- 运行节点
+- 重启次数
+
+### ke_pod_log_list
+
+获取指定应用的Pod日志列表。
+
+**参数：**
+- `namespace` (必需): 命名空间，格式为 tenant-project（如：app-sheyang）
+- `service` (必需): 服务名称（应用名称），可通过 `ke_app_list` 获取
+- `env` (必需): 环境名称，可通过 `ke_env_list` 获取
+- `start_time` (必需): 开始时间（纳秒时间戳）
+- `end_time` (必需): 结束时间（纳秒时间戳）
+- `size` (可选): 返回记录数量，默认100
+- `offset` (可选): 偏移量，默认0
+- `sort` (可选): 排序方式，默认desc（降序），可选asc（升序）
+
+**返回信息：**
+- 日志内容（body）
+- 时间戳
+- Pod名称
+- Pod IP
+- 日志级别
+
+## 开发
+
+### 运行本地开发
+
+```bash
+# 安装依赖
+npm install
+
+# 运行服务
+npm start
+```
+
+### 调试模式
+
+设置 `BD_KE_MCP_DEBUG` 环境变量可启用 DEBUG 级别日志：
+
+```bash
+BD_KE_MCP_DEBUG=1 npm start
+```
+
+## 从 Python 版本迁移
+
+如果你之前使用的是 Python 版本，迁移步骤如下：
+
+1. **配置文件兼容**：`.mcp/bd-ke-mcp.json` 配置格式完全相同，无需修改
+2. **更新 Cursor 配置**：将 MCP 配置中的 `command` 从 `python3` 改为 `node` 或 `npx`
+3. **功能完全兼容**：所有 9 个工具的功能和参数完全一致
+
+## 常见问题
+
+### 1. 配置文件未加载
+- **原因**：项目根目录未正确识别
+- **解决**：设置 `PROJECT_ROOT` 环境变量指向项目根目录
+
+### 2. 网络请求超时
+- **原因**：KE 服务响应慢或网络问题
+- **解决**：检查 `domain` 配置是否正确，确保网络可达
+
+### 3. 认证失败
+- **原因**：`access_token` 无效或过期
+- **解决**：更新配置文件中的 `access_token`
+
+## 日志
+
+日志输出到 stderr，可在 Cursor 的 MCP 日志面板查看。
+
+设置 `BD_KE_MCP_DEBUG` 环境变量可启用 DEBUG 级别日志。
+
+## 许可证
+
+MIT License

package/index.js

@@ -0,0 +1,1088 @@
+#!/usr/bin/env node
+/**
+ * BD-KE MCP Server
+ * MCP (Model Context Protocol) tools for Knowledge Engine application management
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// ==================== 常量定义 ====================
+const VERSION = "1.0.0";
+const CONFIG_FILE_NAME = "bd-ke-mcp.json";
+const FETCH_TIMEOUT = 30000; // 30秒超时
+
+// ==================== 日志系统 ====================
+/**
+ * 日志输出到 stderr（Cursor 会捕获显示）
+ * 注意：不能使用 console.log，会污染 MCP 的 stdio 通信通道
+ */
+const logger = {
+  info: (message, data) => {
+    const timestamp = new Date().toISOString();
+    const dataStr = data ? ` | ${JSON.stringify(data)}` : '';
+    console.error(`[${timestamp}] INFO  ${message}${dataStr}`);
+  },
+  warn: (message, data) => {
+    const timestamp = new Date().toISOString();
+    const dataStr = data ? ` | ${JSON.stringify(data)}` : '';
+    console.error(`[${timestamp}] WARN  ${message}${dataStr}`);
+  },
+  error: (message, data) => {
+    const timestamp = new Date().toISOString();
+    const dataStr = data ? ` | ${JSON.stringify(data)}` : '';
+    console.error(`[${timestamp}] ERROR ${message}${dataStr}`);
+  },
+  debug: (message, data) => {
+    if (process.env.BD_KE_MCP_DEBUG) {
+      const timestamp = new Date().toISOString();
+      const dataStr = data ? ` | ${JSON.stringify(data)}` : '';
+      console.error(`[${timestamp}] DEBUG ${message}${dataStr}`);
+    }
+  }
+};
+
+// ==================== 配置管理 ====================
+
+/**
+ * 获取项目根目录（直接从 PROJECT_ROOT 环境变量获取）
+ */
+function getProjectRoot() {
+  return process.env.PROJECT_ROOT || null;
+}
+
+/**
+ * 加载配置文件
+ * 直接从 PROJECT_ROOT/.mcp/bd-ke-mcp.json 加载
+ */
+function loadConfig() {
+  const config = {};
+  const projectRoot = getProjectRoot();
+  
+  if (!projectRoot) {
+    logger.warn("PROJECT_ROOT 环境变量未设置，无法加载配置文件");
+    return config;
+  }
+
+  const configFile = path.join(projectRoot, ".mcp", CONFIG_FILE_NAME);
+  
+  if (!fs.existsSync(configFile)) {
+    logger.warn("配置文件不存在", { path: configFile });
+    return config;
+  }
+
+  try {
+    const fileContent = fs.readFileSync(configFile, "utf8");
+    const fileConfig = JSON.parse(fileContent);
+    Object.assign(config, fileConfig);
+    logger.info("已加载配置文件", { path: configFile });
+  } catch (error) {
+    logger.error("配置文件加载失败", { error: error.message });
+  }
+
+  return config;
+}
+
+// 全局配置
+let globalConfig = loadConfig();
+
+/**
+ * 重新加载配置（确保获取最新配置）
+ */
+function reloadConfig() {
+  globalConfig = loadConfig();
+  return globalConfig;
+}
+
+/**
+ * 获取配置值
+ */
+function getConfig(key, defaultValue = null) {
+  return globalConfig[key] ?? defaultValue;
+}
+
+/**
+ * 获取租户命名空间（tenant-project 格式）
+ */
+function getTenantNamespace() {
+  const tenant = getConfig("tenant");
+  const project = getConfig("project");
+  if (!tenant || !project) {
+    throw new Error("配置项 tenant 或 project 未设置");
+  }
+  return `${tenant}-${project}`;
+}
+
+// ==================== HTTP 请求 ====================
+
+/**
+ * 带超时的 fetch 请求
+ */
+async function fetchWithTimeout(url, options = {}, timeoutMs = FETCH_TIMEOUT) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error.name === "AbortError") {
+      throw new Error(`请求超时（${timeoutMs}ms）`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * KE API 请求
+ */
+async function keRequest(method, urlPath, options = {}) {
+  const domain = getConfig("domain");
+  const accessToken = getConfig("access_token");
+
+  if (!domain) {
+    throw new Error("配置项 domain 未设置");
+  }
+  if (!accessToken) {
+    throw new Error("配置项 access_token 未设置");
+  }
+
+  const url = `${domain.replace(/\/+$/, "")}/${urlPath.replace(/^\/+/, "")}`;
+  
+  logger.debug("KE API 请求", { method, url });
+
+  const headers = {
+    "leo-user-token": accessToken,
+    "Content-Type": "application/json",
+    ...options.headers
+  };
+
+  const response = await fetchWithTimeout(url, {
+    method,
+    headers,
+    body: options.body ? JSON.stringify(options.body) : undefined
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+
+  const data = await response.json();
+  
+  if (data.rtnCode !== "000000") {
+    throw new Error(data.rtnMsg || "API 返回错误");
+  }
+
+  return data;
+}
+
+// ==================== 工具实现 ====================
+
+/**
+ * ke_app_restart - 重启 KE 应用（通过删除 Pod）
+ */
+async function keAppRestart() {
+  reloadConfig();
+  
+  const application = getConfig("application");
+  const env = getConfig("env");
+  
+  if (!application || !env) {
+    throw new Error("配置项 application 或 env 未设置");
+  }
+
+  const namespace = getTenantNamespace();
+  
+  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);
+
+  // 2. 提取 Pod 名称
+  const podNames = [];
+  const workloads = statusData.rtnData?.workloads || [];
+  for (const workload of workloads) {
+    const pods = workload.pods || [];
+    for (const pod of pods) {
+      if (pod.name) {
+        podNames.push(pod.name);
+      }
+    }
+  }
+
+  logger.info(`找到 ${podNames.length} 个 Pod`);
+
+  if (podNames.length === 0) {
+    return "未找到任何 Pod 节点";
+  }
+
+  // 3. 删除每个 Pod
+  const deletedPods = [];
+  const failedPods = [];
+
+  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);
+      deletedPods.push(podName);
+      logger.info(`已删除 Pod: ${podName}`);
+    } catch (error) {
+      failedPods.push({ pod: podName, error: error.message });
+      logger.error(`删除 Pod 失败: ${podName}`, { error: error.message });
+    }
+  }
+
+  // 4. 构建返回消息
+  let result = `KE 应用重启操作完成\n`;
+  result += `应用: ${application}\n`;
+  result += `环境: ${env}\n\n`;
+  result += `成功重启的 Pod 节点 (${deletedPods.length} 个):\n`;
+  
+  if (deletedPods.length > 0) {
+    for (const pod of deletedPods) {
+      result += `  - ${pod}\n`;
+    }
+  } else {
+    result += "  (无)\n";
+  }
+
+  if (failedPods.length > 0) {
+    result += `\n删除失败的 Pod 节点 (${failedPods.length} 个):\n`;
+    for (const failed of failedPods) {
+      result += `  - ${failed.pod}: ${failed.error}\n`;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * ke_pipeline_list - 获取流水线列表
+ */
+async function kePipelineList(page = 1, pageSize = 20) {
+  reloadConfig();
+  
+  const domain = getConfig("domain");
+  const tenant = getConfig("tenant");
+  const project = getConfig("project");
+  const application = getConfig("application");
+  
+  if (!tenant || !project) {
+    throw new Error("配置项 tenant 或 project 未设置");
+  }
+
+  // 构建 label 参数
+  const label = {
+    tenantName: tenant,
+    projectName: project
+  };
+  if (application) {
+    label.applicationName = application;
+  }
+  
+  // URL 编码 label 参数
+  const labelEncoded = encodeURIComponent(JSON.stringify(label));
+  const group = `${tenant}-${project}`;
+  
+  const url = `pipeline/v1/group/${group}/pipelines/list?page=${page}&pageSize=${pageSize}&searchValue=&label=${labelEncoded}`;
+  
+  logger.info("获取流水线列表", { group, application });
+  
+  const data = await keRequest("GET", url);
+  const pipelinesData = data.rtnData?.data || [];
+  const envMapping = data.rtnData?.env || {};
+  const totalCount = data.rtnData?.count || 0;
+  
+  if (pipelinesData.length === 0) {
+    return "未找到任何流水线";
+  }
+
+  let result = `找到 ${totalCount} 条流水线:\n\n`;
+  
+  for (let i = 0; i < pipelinesData.length; i++) {
+    const pipeline = pipelinesData[i];
+    const pipelineName = pipeline.name || "";
+    const pipelineAlias = pipeline.alias || "";
+    const creator = pipeline.creator || "";
+    const createAt = (pipeline.create_at || "").substring(0, 19).replace("T", " ");
+    const pipelineGroup = pipeline.group || group;
+    const env = envMapping[pipelineName] || "";
+    
+    // 构建流水线地址
+    const pipelineUrl = `${domain}/pipeline/v1/group/${pipelineGroup}/pipelines/${pipelineName}/view`;
+    
+    result += `${i + 1}. ${pipelineAlias || pipelineName}\n`;
+    result += `   流水线名称: ${pipelineName}\n`;
+    result += `   环境: ${env}\n`;
+    result += `   创建者: ${creator}\n`;
+    result += `   创建时间: ${createAt}\n`;
+    result += `   流水线地址: ${pipelineUrl}\n\n`;
+  }
+
+  return result.trim();
+}
+
+/**
+ * ke_pipeline_info - 获取流水线信息
+ */
+async function kePipelineInfo(pipelineUrl) {
+  reloadConfig();
+  
+  if (!pipelineUrl) {
+    throw new Error("参数 pipelineUrl 不能为空");
+  }
+  
+  const accessToken = getConfig("access_token");
+  if (!accessToken) {
+    throw new Error("配置项 access_token 未设置");
+  }
+
+  logger.info("获取流水线信息", { url: pipelineUrl });
+
+  const response = await fetchWithTimeout(pipelineUrl, {
+    method: "GET",
+    headers: {
+      "leo-user-token": accessToken,
+      "Content-Type": "application/json"
+    }
+  });
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+
+  const data = await response.json();
+  
+  if (data.rtnCode !== "000000") {
+    throw new Error(data.rtnMsg || "获取流水线信息失败");
+  }
+
+  // 提取流水线信息
+  const rtnData = data.rtnData || {};
+  const pipelineData = rtnData.data || {};
+  const pipelineName = pipelineData.name || "未知";
+  const metaData = pipelineData.meta_data || {};
+  const globalParams = metaData.global || [];
+
+  let result = `流水线名称: ${pipelineName}\n\n`;
+  result += "执行参数（可修改）:\n\n";
+
+  for (const param of globalParams) {
+    const paramName = param.name || "";
+    const paramDesc = param.desc || "";
+    const paramValue = param.value || "";
+    result += `  ${paramName}: ${paramValue}  # ${paramDesc}\n`;
+  }
+
+  result += "\n" + "=".repeat(60) + "\n";
+  result += "请使用 ke_pipeline_create 工具执行流水线，传入修改后的参数。\n";
+  result += '参数格式: {"参数名": "参数值", ...}';
+
+  return result;
+}
+
+/**
+ * ke_pipeline_create - 执行流水线
+ */
+async function kePipelineCreate(pipelineUrl, globalArguments, deadline = 86400, review = "") {
+  reloadConfig();
+  
+  if (!pipelineUrl) {
+    throw new Error("参数 pipelineUrl 不能为空");
+  }
+  
+  const accessToken = getConfig("access_token");
+  if (!accessToken) {
+    throw new Error("配置项 access_token 未设置");
+  }
+  if (!globalArguments || Object.keys(globalArguments).length === 0) {
+    throw new Error("参数 globalArguments 不能为空");
+  }
+
+  // 将 /view 替换为 /runtimes/create
+  const createUrl = pipelineUrl.replace("/view", "/runtimes/create");
+  
+  logger.info("执行流水线", { url: createUrl, params: globalArguments });
+
+  const response = await fetchWithTimeout(createUrl, {
+    method: "POST",
+    headers: {
+      "leo-user-token": accessToken,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      deadline,
+      globalArguments,
+      review
+    })
+  });
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+
+  const data = await response.json();
+  
+  if (data.rtnCode !== "000000") {
+    throw new Error(data.rtnMsg || "创建流水线失败");
+  }
+
+  let result = "KE 流水线执行已启动\n\n";
+  result += `参数数量: ${Object.keys(globalArguments).length}\n\n`;
+  result += "执行参数:\n";
+  
+  for (const [key, value] of Object.entries(globalArguments)) {
+    result += `  ${key}: ${value}\n`;
+  }
+
+  if (data.rtnData) {
+    result += `\n执行结果:\n  ${JSON.stringify(data.rtnData)}`;
+  }
+
+  return result;
+}
+
+/**
+ * ke_tenants_list - 列出所有租户
+ */
+async function keTenantsList() {
+  reloadConfig();
+  
+  const url = "user-center/v4/tenants/list?page=1&pageSize=100&type=all&single=true";
+  const data = await keRequest("GET", url);
+
+  const tenantsData = data.rtnData?.data || [];
+  
+  if (tenantsData.length === 0) {
+    return "未找到任何租户";
+  }
+
+  let result = `找到 ${tenantsData.length} 个租户:\n\n`;
+  
+  for (const tenant of tenantsData) {
+    result += `  租户ID: ${tenant.tenantId || ""}\n`;
+    result += `  租户名称: ${tenant.tenantName || ""}\n`;
+    result += `  租户描述: ${tenant.tenantDesc || ""}\n\n`;
+  }
+
+  return result.trim();
+}
+
+/**
+ * ke_projects_list - 列出所有项目
+ */
+async function keProjectsList() {
+  reloadConfig();
+  
+  const tenant = getConfig("tenant");
+  if (!tenant) {
+    throw new Error("配置项 tenant 未设置");
+  }
+
+  const url = `user-center/v4/tenants/${tenant}/projects/list`;
+  const data = await keRequest("GET", url);
+
+  const projectsData = data.rtnData?.data || [];
+  
+  if (projectsData.length === 0) {
+    return "未找到任何项目";
+  }
+
+  let result = `找到 ${projectsData.length} 个项目:\n\n`;
+  
+  for (const project of projectsData) {
+    result += `  租户名称: ${project.tenantName || ""}\n`;
+    result += `  项目ID: ${project.projectId || ""}\n`;
+    result += `  项目名称: ${project.projectName || ""}\n`;
+    result += `  项目描述: ${project.projectDesc || ""}\n`;
+    result += `  命名空间: ${project.namespace || ""}\n\n`;
+  }
+
+  return result.trim();
+}
+
+/**
+ * ke_app_list - 列出所有应用
+ */
+async function keAppList() {
+  reloadConfig();
+  
+  const namespace = getTenantNamespace();
+  const url = `amp/v4/namespace/${namespace}/applications/list?page=1&pageSize=999`;
+  const data = await keRequest("GET", url);
+
+  const appsData = data.rtnData?.data || [];
+  
+  if (appsData.length === 0) {
+    return "未找到任何应用";
+  }
+
+  let result = `找到 ${appsData.length} 个应用:\n\n`;
+  
+  for (const app of appsData) {
+    result += `  应用名称: ${app.name || ""}\n`;
+    result += `  显示名称: ${app.displayName || ""}\n`;
+    result += `  分组: ${app.group || ""}\n\n`;
+  }
+
+  return result.trim();
+}
+
+/**
+ * ke_env_list - 获取环境列表
+ */
+async function keEnvList() {
+  reloadConfig();
+  
+  const tenant = getConfig("tenant");
+  if (!tenant) {
+    throw new Error("配置项 tenant 未设置");
+  }
+
+  const url = `user-center/v4/tenants/${tenant}/clusters/all/list`;
+  const data = await keRequest("GET", url);
+
+  const clustersData = data.rtnData?.data || [];
+  const envList = clustersData.map(c => c.name).filter(Boolean);
+  
+  if (envList.length === 0) {
+    return `租户 ${tenant} 未找到任何环境`;
+  }
+
+  let result = `租户 ${tenant} 的环境列表（共 ${envList.length} 个）:\n\n`;
+  
+  for (const envName of envList) {
+    result += `  - ${envName}\n`;
+  }
+
+  return result;
+}
+
+/**
+ * ke_pods_list - 获取 Pod 列表
+ */
+async function kePodsList(appName) {
+  reloadConfig();
+  
+  if (!appName) {
+    throw new Error("参数 appName 不能为空");
+  }
+
+  const namespace = getTenantNamespace();
+  const env = getConfig("env");
+  
+  if (!env) {
+    throw new Error("配置项 env 未设置");
+  }
+
+  const url = `amp/v4/namespace/${namespace}/env/${env}/applications/${appName}/appstatus/view?canary=false`;
+  const data = await keRequest("GET", url);
+
+  // 提取 Pod 列表
+  const podsList = [];
+  const workloads = data.rtnData?.workloads || [];
+  
+  for (const workload of workloads) {
+    const pods = workload.pods || [];
+    for (const pod of pods) {
+      const unstructured = pod.unstructured || {};
+      const spec = unstructured.spec || {};
+      const status = unstructured.status || {};
+      
+      // 计算重启次数
+      const containerStatuses = status.containerStatuses || [];
+      let totalRestartCount = 0;
+      for (const cs of containerStatuses) {
+        totalRestartCount += cs.restartCount || 0;
+      }
+
+      podsList.push({
+        name: pod.name || "",
+        status: pod.status || "",
+        createTime: (pod.createTime || "").substring(0, 19),
+        podIp: pod.podIp || "",
+        nodeName: spec.nodeName || "",
+        restartCount: totalRestartCount
+      });
+    }
+  }
+
+  if (podsList.length === 0) {
+    return `应用 ${appName} 未找到任何 Pod 实例`;
+  }
+
+  let result = `应用 ${appName} 的 Pod 列表（共 ${podsList.length} 个实例）:\n\n`;
+  result += `${"实例名称".padEnd(45)} ${"状态".padEnd(10)} ${"创建时间".padEnd(22)} ${"容器IP".padEnd(16)} ${"运行节点".padEnd(20)} ${"重启次数"}\n`;
+  result += "-".repeat(130) + "\n";
+
+  for (const pod of podsList) {
+    result += `${pod.name.padEnd(45)} ${pod.status.padEnd(10)} ${pod.createTime.padEnd(22)} ${pod.podIp.padEnd(16)} ${pod.nodeName.padEnd(20)} ${pod.restartCount}\n`;
+  }
+
+  return result;
+}
+
+/**
+ * ke_pod_log_list - 获取 Pod 日志列表
+ */
+async function kePodLogList(namespace, service, env, startTime, endTime, size = 100, offset = 0, sort = "desc") {
+  reloadConfig();
+  
+  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 未设置");
+  }
+
+  const url = `armilla/v1/group/${tenant}/env/${env}/log/list`;
+  
+  const requestBody = {
+    keys: [],
+    sort,
+    offset,
+    size,
+    log_source: "application",
+    serviceNames: [],
+    start_time: startTime,
+    end_time: endTime,
+    tags: [
+      {
+        key: "_namespace_name_",
+        keyKind: "FixedLabel",
+        keyType: "string",
+        operator: "Equals",
+        stringValues: [namespace]
+      },
+      {
+        key: "_service_name_",
+        keyKind: "FixedLabel",
+        keyType: "string",
+        operator: "Equals",
+        stringValues: [service]
+      }
+    ],
+    log_version: "v3"
+  };
+
+  const data = await keRequest("POST", url, { body: requestBody });
+  const records = data.rtnData?.records || [];
+
+  if (records.length === 0) {
+    return `未找到任何日志记录（namespace: ${namespace}, service: ${service}, env: ${env}）`;
+  }
+
+  let result = `Pod 日志列表（共 ${records.length} 条记录）:\n`;
+  result += `命名空间: ${namespace}\n`;
+  result += `服务名称: ${service}\n`;
+  result += `环境: ${env}\n\n`;
+
+  for (const record of records) {
+    const body = record.body || "";
+    const time = record.time;
+    const stringTags = record.stringTags || {};
+    const podName = stringTags._pod_name_ || "";
+    const podIp = stringTags._pod_ip_ || "";
+    const level = stringTags._level_ || "";
+
+    // 格式化时间戳
+    let timeStr = "";
+    if (time) {
+      try {
+        const timeSeconds = Math.floor(Number(time) / 1000000000);
+        const date = new Date(timeSeconds * 1000);
+        timeStr = date.toISOString().replace("T", " ").substring(0, 19);
+      } catch {
+        timeStr = String(time);
+      }
+    }
+
+    result += `[${timeStr}] [${podName}] [${podIp}] [${level}]\n`;
+    result += `  ${body}\n\n`;
+  }
+
+  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({
+  name: "bd-ke-mcp",
+  version: VERSION
+});
+
+// 注册工具：ke_app_restart
+server.registerTool(
+  "ke_app_restart",
+  {
+    description: "重启 KE 应用（通过删除 Pod 触发自动重建）",
+    inputSchema: {}
+  },
+  async () => {
+    try {
+      const result = await keAppRestart();
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      logger.error("ke_app_restart 失败", { error: error.message });
+      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
+    }
+  }
+);
+
+// 注册工具：ke_pipeline_list
+server.registerTool(
+  "ke_pipeline_list",
+  {
+    description: "获取 KE 流水线列表，根据配置文件中的 tenant、project、application 筛选",
+    inputSchema: {
+      page: z.number().optional().default(1).describe("页码，默认 1"),
+      pageSize: z.number().optional().default(20).describe("每页数量，默认 20")
+    }
+  },
+  async ({ page, pageSize }) => {
+    try {
+      const result = await kePipelineList(page, pageSize);
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      logger.error("ke_pipeline_list 失败", { error: error.message });
+      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
+    }
+  }
+);
+
+// 注册工具：ke_pipeline_info
+server.registerTool(
+  "ke_pipeline_info",
+  {
+    description: "获取 KE 流水线信息，包括流水线名称和执行参数",
+    inputSchema: {
+      pipelineUrl: z.string().describe("流水线地址（如：http://pro.kubeease.cn/pipeline/v1/group/tenant-project/pipelines/app-xxx/view）")
+    }
+  },
+  async ({ pipelineUrl }) => {
+    try {
+      const result = await kePipelineInfo(pipelineUrl);
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      logger.error("ke_pipeline_info 失败", { error: error.message });
+      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
+    }
+  }
+);
+
+// 注册工具：ke_pipeline_create
+server.registerTool(
+  "ke_pipeline_create",
+  {
+    description: "执行 KE 流水线（创建流水线运行时）",
+    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("审核信息")
+    }
+  },
+  async ({ pipelineUrl, globalArguments, deadline, review }) => {
+    try {
+      const result = await kePipelineCreate(pipelineUrl, globalArguments, deadline, review);
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      logger.error("ke_pipeline_create 失败", { error: error.message });
+      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
+    }
+  }
+);
+
+// 注册工具：ke_tenants_list
+server.registerTool(
+  "ke_tenants_list",
+  {
+    description: "列出所有的租户",
+    inputSchema: {}
+  },
+  async () => {
+    try {
+      const result = await keTenantsList();
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      logger.error("ke_tenants_list 失败", { error: error.message });
+      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
+    }
+  }
+);
+
+// 注册工具：ke_projects_list
+server.registerTool(
+  "ke_projects_list",
+  {
+    description: "列出所有的项目",
+    inputSchema: {}
+  },
+  async () => {
+    try {
+      const result = await keProjectsList();
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      logger.error("ke_projects_list 失败", { error: error.message });
+      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
+    }
+  }
+);
+
+// 注册工具：ke_app_list
+server.registerTool(
+  "ke_app_list",
+  {
+    description: "列出所有的应用",
+    inputSchema: {}
+  },
+  async () => {
+    try {
+      const result = await keAppList();
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      logger.error("ke_app_list 失败", { error: error.message });
+      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
+    }
+  }
+);
+
+// 注册工具：ke_env_list
+server.registerTool(
+  "ke_env_list",
+  {
+    description: "获取当前租户下的所有环境列表",
+    inputSchema: {
+      projectName: z.string().optional().describe("项目名称（已废弃，保留以保持向后兼容）")
+    }
+  },
+  async () => {
+    try {
+      const result = await keEnvList();
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      logger.error("ke_env_list 失败", { error: error.message });
+      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
+    }
+  }
+);
+
+// 注册工具：ke_pods_list
+server.registerTool(
+  "ke_pods_list",
+  {
+    description: "获取指定应用的 Pod 实例列表，包含实例名称、状态、创建时间、容器IP、运行节点、重启次数等信息",
+    inputSchema: {
+      appName: z.string().describe("应用名称，可通过 ke_app_list 获取")
+    }
+  },
+  async ({ appName }) => {
+    try {
+      const result = await kePodsList(appName);
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      logger.error("ke_pods_list 失败", { error: error.message });
+      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
+    }
+  }
+);
+
+// 注册工具：ke_pod_log_list
+server.registerTool(
+  "ke_pod_log_list",
+  {
+    description: "获取指定应用的 Pod 日志列表",
+    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（升序）")
+    }
+  },
+  async ({ namespace, service, env, start_time, end_time, size, offset, sort }) => {
+    try {
+      const result = await kePodLogList(namespace, service, env, start_time, end_time, size, offset, sort);
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      logger.error("ke_pod_log_list 失败", { error: error.message });
+      return { content: [{ type: "text", text: `错误: ${error.message}` }], isError: true };
+    }
+  }
+);
+
+// 注册工具：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() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  logger.info("BD-KE MCP 服务已启动", {
+    version: VERSION,
+    nodeVersion: process.version,
+    platform: os.platform(),
+    pid: process.pid,
+    projectRoot: getProjectRoot(),
+    tools: [
+      "ke_app_restart",
+      "ke_pipeline_list",
+      "ke_pipeline_info",
+      "ke_pipeline_create",
+      "ke_tenants_list",
+      "ke_projects_list",
+      "ke_app_list",
+      "ke_env_list",
+      "ke_pods_list",
+      "ke_pod_log_list",
+      "ke_pod_exec"
+    ]
+  });
+}
+
+main().catch((err) => {
+  logger.error("MCP 服务启动失败", { error: err.message, stack: err.stack });
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@junjun-org/bd-ke-mcp",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "MCP (Model Context Protocol) tools for BD-KE - Knowledge Engine application management",
+  "main": "index.js",
+  "bin": {
+    "bd-ke-mcp": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "start:stdio": "node index.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ke",
+    "knowledge-engine",
+    "kubernetes",
+    "pod",
+    "pipeline",
+    "cursor",
+    "ai"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.18.2",
+    "zod": "^3.25.76"
+  },
+  "files": [
+    "index.js",
+    "README.md",
+    "LICENSE"
+  ]
+}