mcp-log-query-server 1.0.0

package/server-sse.js

@@ -0,0 +1,203 @@
+/**
+ * Log Query MCP Server - SSE/HTTP 模式
+ * 
+ * 支持通过 HTTP 和 Server-Sent Events 与 MCP 客户端通信
+ * 适用于 Docker 部署
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import express from 'express';
+import cors from 'cors';
+import { findService, getAllServices, DEFAULTS } from './config.js';
+import { queryLog, testConnection } from './ssh-client.js';
+
+const app = express();
+const PORT = process.env.PORT || 3100;
+
+// 启用 CORS
+app.use(cors());
+app.use(express.json());
+
+// 存储活跃的 SSE 连接
+const transports = {};
+
+// 健康检查端点
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', service: 'mcp-log-query' });
+});
+
+// SSE 端点 - 客户端连接
+app.get('/sse', async (req, res) => {
+  console.log('[SSE] 新客户端连接');
+
+  // 设置 SSE 响应头
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.flushHeaders();
+
+  // 生成 sessionId
+  const sessionId = Date.now().toString();
+
+  // 创建 SSE transport，传入 sessionId
+  const transport = new SSEServerTransport(`/message?sessionId=${sessionId}`, res);
+  transports[sessionId] = transport;
+
+  // 创建 MCP Server
+  const server = new McpServer({
+    name: 'mcp-log-query',
+    version: '1.0.0'
+  });
+
+  // 注册工具
+  registerTools(server);
+
+  // 连接 transport
+  try {
+    await server.connect(transport);
+    console.log(`[SSE] 客户端已连接, sessionId: ${sessionId}`);
+  } catch (err) {
+    console.error('[SSE] 连接错误:', err);
+  }
+
+  // 保持连接活跃 - 每 30 秒发送心跳
+  const heartbeat = setInterval(() => {
+    if (!res.writableEnded) {
+      res.write(': heartbeat\n\n');
+    }
+  }, 30000);
+
+  // 清理断开的连接
+  res.on('close', () => {
+    console.log(`[SSE] 客户端断开, sessionId: ${sessionId}`);
+    clearInterval(heartbeat);
+    delete transports[sessionId];
+  });
+});
+
+// 消息端点 - 接收客户端请求
+app.post('/message', async (req, res) => {
+  const sessionId = req.query.sessionId;
+  const transport = transports[sessionId];
+  
+  if (!transport) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+  
+  await transport.handlePostMessage(req, res);
+});
+
+/**
+ * 注册 MCP 工具
+ */
+function registerTools(server) {
+  // query_log 工具
+  server.tool('query_log', {
+    description: '查询服务容器的日志文件。返回最近的日志内容。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        service: {
+          type: 'string',
+          description: '服务名称，如 clife-senior-health、clife-senior-archive，或别名如 health、archive'
+        },
+        lines: {
+          type: 'number',
+          description: '返回的日志行数，默认 100',
+          default: 100
+        }
+      },
+      required: ['service']
+    }
+  }, async (args) => {
+    const service = findService(args.service);
+    if (!service) {
+      return { content: [{ type: 'text', text: `错误: 未找到服务 "${args.service}"` }] };
+    }
+    
+    const lines = args.lines || DEFAULTS.lines;
+    const command = `tail -${lines}`;
+    
+    console.log(`[MCP] 查询日志: ${service.name}`);
+    const result = await queryLog(service, command);
+    
+    return {
+      content: [{
+        type: 'text',
+        text: `## ${service.name} 日志 (最近 ${lines} 行)\n\n\`\`\`\n${result}\n\`\`\``
+      }]
+    };
+  });
+  
+  // search_log 工具
+  server.tool('search_log', {
+    description: '在服务日志中搜索关键词',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        service: { type: 'string', description: '服务名称或别名' },
+        keyword: { type: 'string', description: '搜索关键词' },
+        context_lines: { type: 'number', description: '上下文行数', default: 5 },
+        case_sensitive: { type: 'boolean', description: '区分大小写', default: false }
+      },
+      required: ['service', 'keyword']
+    }
+  }, async (args) => {
+    const service = findService(args.service);
+    if (!service) {
+      return { content: [{ type: 'text', text: `错误: 未找到服务 "${args.service}"` }] };
+    }
+    
+    const grepFlags = args.case_sensitive ? '' : '-i';
+    const contextLines = args.context_lines || 5;
+    const command = `grep ${grepFlags} -C ${contextLines} "${args.keyword}"`;
+    
+    console.log(`[MCP] 搜索日志: ${service.name}, 关键词: ${args.keyword}`);
+    const result = await queryLog(service, command);
+    
+    return {
+      content: [{
+        type: 'text',
+        text: `## ${service.name} 日志搜索结果\n\n**关键词**: ${args.keyword}\n\n\`\`\`\n${result || '未找到匹配内容'}\n\`\`\``
+      }]
+    };
+  });
+  
+  // list_services 工具
+  server.tool('list_services', {
+    description: '列出所有可查询日志的服务',
+    inputSchema: { type: 'object', properties: {} }
+  }, async () => {
+    const services = getAllServices();
+    const text = services.map(s => 
+      `- **${s.name}**: ${s.description}\n  别名: ${s.aliases.join(', ')}`
+    ).join('\n');
+    
+    return { content: [{ type: 'text', text: `## 可用服务\n\n${text}` }] };
+  });
+  
+  // test_connection 工具
+  server.tool('test_connection', {
+    description: '测试 SSH 连接',
+    inputSchema: { type: 'object', properties: {} }
+  }, async () => {
+    const result = await testConnection();
+    return {
+      content: [{
+        type: 'text',
+        text: result.success ? '✅ SSH 连接正常' : `❌ 连接失败: ${result.error}`
+      }]
+    };
+  });
+}
+
+// 启动服务器
+app.listen(PORT, () => {
+  console.log(`[MCP] Log Query Server (SSE) 已启动，端口: ${PORT}`);
+  console.log(`[MCP] SSE 端点: http://localhost:${PORT}/sse`);
+  console.log(`[MCP] 健康检查: http://localhost:${PORT}/health`);
+});
+

package/ssh-client.js

@@ -0,0 +1,326 @@
+/**
+ * SSH Client - 通过 JumpServer 堡垒机连接 K8s 服务器并执行命令
+ *
+ * JumpServer 交互流程：
+ * 1. SSH 连接堡垒机，等待 Opt> 提示符
+ * 2. 输入目标服务器 IP，等待 [Host]> 提示符
+ * 3. 输入服务器 ID (如 1)，等待进入服务器 shell
+ * 4. 执行 kubectl 命令查询日志
+ * 5. 退出
+ *
+ * 注意：
+ * - 堡垒机只有 30 秒等待时间，必须快速响应！
+ * - 使用 \r 而不是 \n 发送命令
+ */
+
+import { Client } from 'ssh2';
+import { JUMP_HOST, K8S_SERVER, DEFAULTS } from './config.js';
+
+/**
+ * 执行日志查询
+ * @param {Object} service - 服务配置
+ * @param {string} command - 日志查询命令（如 tail -100 *.log）
+ * @param {Object} options - 选项
+ * @returns {Promise<string>} 日志内容
+ */
+export async function queryLog(service, command, options = {}) {
+  const timeout = options.timeout || DEFAULTS.timeout;
+
+  return new Promise((resolve, reject) => {
+    const conn = new Client();
+    let buffer = '';  // 累积所有输出
+    let timeoutId;
+    let stage = 'init';  // init -> opt -> host -> server -> kubectl -> done
+    let kubectlOutput = '';
+    let collectingOutput = false;
+
+    // 设置超时
+    timeoutId = setTimeout(() => {
+      conn.end();
+      reject(new Error(`命令执行超时 (${timeout}ms)`));
+    }, timeout);
+
+    conn.on('ready', () => {
+      console.error('[SSH] 已连接到堡垒机');
+
+      conn.shell({ term: 'xterm', rows: 24, cols: 500 }, (err, stream) => {
+        if (err) {
+          clearTimeout(timeoutId);
+          reject(err);
+          return;
+        }
+
+        stream.on('close', () => {
+          clearTimeout(timeoutId);
+          conn.end();
+
+          // 清理输出
+          const cleanOutput = cleanTerminalOutput(kubectlOutput || buffer);
+          resolve(cleanOutput);
+        });
+
+        stream.on('data', (data) => {
+          const text = data.toString();
+          buffer += text;
+
+          if (collectingOutput) {
+            kubectlOutput += text;
+          }
+
+          // JumpServer 状态机 - 检查累积的 buffer
+
+          // 阶段1: 等待 Opt> 提示符
+          if (stage === 'init' && buffer.includes('Opt>')) {
+            stage = 'opt';
+            console.error('[SSH] 输入目标服务器 IP');
+            stream.write(K8S_SERVER.host + '\r');
+          }
+          // 阶段2: 等待 [Host]> 提示符（搜索结果列表后）
+          else if (stage === 'opt' && buffer.includes('[Host]>')) {
+            stage = 'host';
+            console.error('[SSH] 选择服务器 ID: ' + K8S_SERVER.selectOption);
+            stream.write(K8S_SERVER.selectOption + '\r');
+          }
+          // 阶段3: 等待进入服务器 shell（检测 ~]$ 或 ~]# 提示符）
+          else if (stage === 'host' && (buffer.includes('~]$') || buffer.includes('~]#'))) {
+            stage = 'server';
+            console.error('[SSH] 已进入服务器，执行 kubectl 命令');
+
+            // 构建并执行 kubectl 命令
+            const kubectlCmd = buildKubectlCommand(service, command);
+            console.error(`[SSH] 命令: ${kubectlCmd.substring(0, 80)}...`);
+
+            // 重置 buffer，开始收集 kubectl 输出
+            kubectlOutput = '';
+            collectingOutput = true;
+
+            stream.write(kubectlCmd + '\r');
+            stage = 'kubectl';
+          }
+          // 阶段4: kubectl 执行完成
+          else if (stage === 'kubectl' && collectingOutput && kubectlOutput.length > 50) {
+            // 检测命令执行完成（返回到 shell 提示符）
+            if (kubectlOutput.includes('~]$') || kubectlOutput.includes('~]#')) {
+              stage = 'done';
+              collectingOutput = false;
+              console.error('[SSH] 命令执行完成，退出');
+
+              // 立即退出
+              stream.write('exit\r');
+              stream.write('exit\r');
+              setTimeout(() => stream.end(), 500);
+            }
+          }
+        });
+
+        stream.stderr.on('data', (data) => {
+          console.error('[SSH stderr]', data.toString());
+        });
+      });
+    });
+
+    conn.on('error', (err) => {
+      clearTimeout(timeoutId);
+      reject(new Error(`SSH 连接错误: ${err.message}`));
+    });
+
+    // 连接堡垒机
+    conn.connect({
+      host: JUMP_HOST.host,
+      port: JUMP_HOST.port,
+      username: JUMP_HOST.username,
+      password: JUMP_HOST.password,
+      readyTimeout: DEFAULTS.connectTimeout
+    });
+  });
+}
+
+/**
+ * 构建 kubectl exec 命令
+ * @param {Object} service - 服务配置
+ * @param {string} logCommand - 日志命令，如 "tail -100" 或 "grep error"
+ */
+function buildKubectlCommand(service, logCommand) {
+  const { namespace, podPattern, logPath, logFile } = service;
+  const file = logFile || 'normal.log';
+  const fullPath = `${logPath}/${file}`;
+
+  // 构建完整命令
+  // 例如: kubectl exec pod/xxx -n namespace -- tail -100 /path/to/normal.log
+  return `kubectl exec $(kubectl get pod -n ${namespace} -o name | grep ${podPattern} | head -1) -n ${namespace} -- ${logCommand} ${fullPath}`;
+}
+
+/**
+ * 清理终端输出中的控制字符
+ */
+function cleanTerminalOutput(output) {
+  return output
+    // 移除 ANSI 转义序列
+    .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '')
+    // 移除其他控制字符
+    .replace(/\x1B\][^\x07]*\x07/g, '')
+    // 移除回车符
+    .replace(/\r/g, '')
+    // 移除堡垒机提示信息（根据实际情况调整）
+    .split('\n')
+    .filter(line => {
+      // 过滤掉提示行和空行
+      const trimmed = line.trim();
+      if (!trimmed) return false;
+      if (trimmed.startsWith('Last login:')) return false;
+      if (trimmed.includes('Welcome')) return false;
+      if (trimmed.match(/^\[.*@.*\][$#]/)) return false;
+      return true;
+    })
+    .join('\n')
+    .trim();
+}
+
+/**
+ * 测试 SSH 连接
+ */
+export async function testConnection() {
+  return new Promise((resolve, reject) => {
+    const conn = new Client();
+    
+    const timeoutId = setTimeout(() => {
+      conn.end();
+      reject(new Error('连接超时'));
+    }, DEFAULTS.connectTimeout);
+    
+    conn.on('ready', () => {
+      clearTimeout(timeoutId);
+      conn.end();
+      resolve({ success: true, message: '堡垒机连接成功' });
+    });
+    
+    conn.on('error', (err) => {
+      clearTimeout(timeoutId);
+      reject(new Error(`连接失败: ${err.message}`));
+    });
+    
+    conn.connect({
+      host: JUMP_HOST.host,
+      port: JUMP_HOST.port,
+      username: JUMP_HOST.username,
+      password: JUMP_HOST.password,
+      readyTimeout: DEFAULTS.connectTimeout
+    });
+  });
+}
+
+
+/**
+ * 执行通用 kubectl 命令
+ * @param {string} kubectlCommand - 完整的 kubectl 命令
+ * @param {Object} options - 选项
+ * @returns {Promise<string>} 命令输出
+ */
+export async function executeKubectl(kubectlCommand, options = {}) {
+  const timeout = options.timeout || DEFAULTS.timeout;
+
+  return new Promise((resolve, reject) => {
+    const conn = new Client();
+    let buffer = '';
+    let timeoutId;
+    let stage = 'init';
+    let kubectlOutput = '';
+    let collectingOutput = false;
+
+    // 设置超时
+    timeoutId = setTimeout(() => {
+      conn.end();
+      reject(new Error(`命令执行超时 (${timeout}ms)`));
+    }, timeout);
+
+    conn.on('ready', () => {
+      console.error('[SSH] 已连接到堡垒机');
+
+      conn.shell({ term: 'xterm', rows: 24, cols: 500 }, (err, stream) => {
+        if (err) {
+          clearTimeout(timeoutId);
+          reject(err);
+          return;
+        }
+
+        stream.on('close', () => {
+          clearTimeout(timeoutId);
+          conn.end();
+
+          // 清理输出
+          const cleanOutput = cleanTerminalOutput(kubectlOutput || buffer);
+          resolve(cleanOutput);
+        });
+
+        stream.on('data', (data) => {
+          const text = data.toString();
+          buffer += text;
+
+          if (collectingOutput) {
+            kubectlOutput += text;
+          }
+
+          // JumpServer 状态机
+
+          // 阶段1: 等待 Opt> 提示符
+          if (stage === 'init' && buffer.includes('Opt>')) {
+            stage = 'opt';
+            console.error('[SSH] 输入目标服务器 IP');
+            stream.write(K8S_SERVER.host + '\r');
+          }
+          // 阶段2: 等待 [Host]> 提示符
+          else if (stage === 'opt' && buffer.includes('[Host]>')) {
+            stage = 'host';
+            console.error('[SSH] 选择服务器 ID: ' + K8S_SERVER.selectOption);
+            stream.write(K8S_SERVER.selectOption + '\r');
+          }
+          // 阶段3: 等待进入服务器 shell
+          else if (stage === 'host' && (buffer.includes('~]$') || buffer.includes('~]#'))) {
+            stage = 'server';
+            console.error('[SSH] 已进入服务器，执行 kubectl 命令');
+            console.error(`[SSH] 命令: ${kubectlCommand.substring(0, 100)}...`);
+
+            // 重置 buffer，开始收集 kubectl 输出
+            kubectlOutput = '';
+            collectingOutput = true;
+
+            stream.write(kubectlCommand + '\r');
+            stage = 'kubectl';
+          }
+          // 阶段4: kubectl 执行完成
+          else if (stage === 'kubectl' && collectingOutput && kubectlOutput.length > 50) {
+            // 检测命令执行完成（返回到 shell 提示符）
+            if (kubectlOutput.includes('~]$') || kubectlOutput.includes('~]#')) {
+              stage = 'done';
+              collectingOutput = false;
+              console.error('[SSH] 命令执行完成，退出');
+
+              // 立即退出
+              stream.write('exit\r');
+              stream.write('exit\r');
+              setTimeout(() => stream.end(), 500);
+            }
+          }
+        });
+
+        stream.stderr.on('data', (data) => {
+          console.error('[SSH stderr]', data.toString());
+        });
+      });
+    });
+
+    conn.on('error', (err) => {
+      clearTimeout(timeoutId);
+      reject(new Error(`SSH 连接错误: ${err.message}`));
+    });
+
+    // 连接堡垒机
+    conn.connect({
+      host: JUMP_HOST.host,
+      port: JUMP_HOST.port,
+      username: JUMP_HOST.username,
+      password: JUMP_HOST.password,
+      readyTimeout: DEFAULTS.connectTimeout
+    });
+  });
+}