mcp-log-query-server 3.5.3 → 3.6.1

package/logger.js

@@ -1,9 +1,12 @@
 /**
- * 轻量日志模块：console.error + 本地文件追加
+ * 轻量日志模块：本地文件追加（默认不走 stderr）
  *
- * 为什么需要文件日志？
- * Windsurf 不会把 MCP server 的 stderr 落盘到 %APPDATA%\Windsurf\logs，
- * 只在 Output 面板实时显示。一旦进程重启、面板关闭，信息就丢了。
+ * ⚠️ 重要背景（3.6.1）：
+ * Windsurf 根本没有 MCP 专属的 Output 频道，从不读取子进程的 stderr。
+ * Node 默认 stderr pipe buffer ~64KB，满了后 `console.error` 会**同步阻塞 event loop**
+ * → 整个 MCP 进程冻结，新请求来了不处理，已发出的 fetch 不推进，cancel signal 也接收不到。
+ *
+ * 因此默认只写文件，stderr 仅在显式要求时开启（用于单独调试，MCP server 场景禁用）。
  *
  * 用法：
  *   import { log } from './logger.js';
@@ -16,7 +19,8 @@
  * 环境变量：
  * - MCP_LOG_FILE: 自定义日志文件路径（默认 <tmpdir>/mcp-log-query.log）
  * - MCP_LOG_MAX_BYTES: 单文件最大字节数（默认 10MB，超过则轮转到 .1）
- * - MCP_LOG_DISABLE: 设为 '1' 则禁用文件日志（只走 stderr）
+ * - MCP_LOG_DISABLE: 设为 '1' 则完全禁用日志（文件+stderr 都不写）
+ * - MCP_LOG_STDERR: 设为 '1' 时**同时**写 stderr（独立调试用，MCP 子进程模式下不要开）
  */
 
 import fs from 'node:fs';
@@ -26,6 +30,8 @@ import path from 'node:path';
 const LOG_FILE = process.env.MCP_LOG_FILE || path.join(os.tmpdir(), 'mcp-log-query.log');
 const MAX_BYTES = parseInt(process.env.MCP_LOG_MAX_BYTES || `${10 * 1024 * 1024}`, 10);
 const DISABLED = process.env.MCP_LOG_DISABLE === '1';
+// 默认不走 stderr（MCP 子进程下会被 host 无限 backpressure 阻塞 event loop）
+const WRITE_STDERR = process.env.MCP_LOG_STDERR === '1';
 
 // 懒初始化：首次写入时再检查目录
 let initialized = false;
@@ -41,8 +47,8 @@ function ensureInit() {
       LOG_FILE,
       `\n========== [${new Date().toISOString()}] MCP log-query 进程启动 pid=${process.pid} ==========\n`
     );
-  } catch (err) {
-    console.error('[logger] 初始化文件日志失败，仅使用 stderr:', err.message);
+  } catch {
+    // 文件初始化失败，静默（同 log 函数的考虑）
   }
 }
 
@@ -59,13 +65,14 @@ function rotateIfNeeded() {
 }
 
 /**
- * 写一条日志：stderr + 可选本地文件
+ * 写一条日志：默认仅本地文件；MCP_LOG_STDERR=1 时同时写 stderr
+ *
+ * ⚠️ 重要：MCP 子进程下 stderr 管道会被 host 无限 backpressure 阻塞 event loop，
+ * 所以默认禁用 stderr 输出。只在独立调试（非 MCP 模式）时开启。
+ *
  * @param {string} msg - 日志内容（不需要带时间戳，本函数自动加）
  */
 export function log(msg) {
-  // stderr 永远写，兼容 Windsurf Output 面板实时查看
-  console.error(msg);
-
   if (DISABLED) return;
 
   ensureInit();
@@ -74,12 +81,15 @@ export function log(msg) {
   try {
     rotateIfNeeded();
     fs.appendFileSync(LOG_FILE, line);
-  } catch (err) {
-    // 文件写失败不能影响主流程，但 stderr 提示一次
-    if (!log._warnedFileFail) {
-      log._warnedFileFail = true;
-      console.error('[logger] 写日志文件失败（后续不再提示）:', err.message);
-    }
+  } catch {
+    // 文件写失败静默忽略：不能为了日志去打 stderr（会阻塞 event loop）
+    // 也不缓存 warning；调试请检查磁盘 / 权限
+  }
+
+  // 可选 stderr 输出（独立调试用）
+  if (WRITE_STDERR) {
+    // 直接 write，失败忽略；不用 console.error 以免同步阻塞
+    try { process.stderr.write(msg + '\n'); } catch {}
   }
 }
 

package/loki-client.js

@@ -67,14 +67,25 @@ export async function queryLoki(envName, expr, options = {}) {
 
   log(`[Loki] 查询: env=${envName}, expr=${expr}`);
 
-  // 带超时的 fetch —— AbortController 覆盖 fetch + body 读取全过程
-  // 之前的 bug：fetch resolve 后立刻 clearTimeout，导致 resp.json() 读 body 卡住时无保护
+  // 带超时 + 用户 cancel 的 fetch —— AbortController 覆盖 fetch + body 读取全过程
+  // 用户 signal (options.signal) 一旦 abort，立即中断；内部 30s timer 也触发 abort
   const controller = new AbortController();
   const timer = setTimeout(() => {
     log(`[Loki] ⏱ 超时 ${LOKI_FETCH_TIMEOUT}ms，主动 abort: env=${envName}, expr=${expr.substring(0, 80)}`);
-    controller.abort();
+    controller.abort(new Error('TIMEOUT'));
   }, LOKI_FETCH_TIMEOUT);
 
+  // 用户 cancel 穿透
+  const userSignal = options.signal;
+  const onUserAbort = () => {
+    log(`[Loki] ⊗ 用户 cancel，主动 abort: env=${envName}`);
+    controller.abort(new Error('USER_CANCELLED'));
+  };
+  if (userSignal) {
+    if (userSignal.aborted) onUserAbort();
+    else userSignal.addEventListener('abort', onUserAbort, { once: true });
+  }
+
   try {
     const resp = await fetch(url, {
       method: 'POST',
@@ -94,11 +105,18 @@ export async function queryLoki(envName, expr, options = {}) {
     return parseLokiResponse(data);
   } catch (e) {
     if (e.name === 'AbortError') {
+      // 区分原因：用户 cancel vs 超时
+      if (userSignal && userSignal.aborted) {
+        const err = new Error('CANCELLED');
+        err.name = 'AbortError';
+        throw err;
+      }
       throw new Error(`Loki 查询超时（${LOKI_FETCH_TIMEOUT}ms）`);
     }
     throw e;
   } finally {
     clearTimeout(timer);
+    if (userSignal) userSignal.removeEventListener('abort', onUserAbort);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-log-query-server",
-  "version": "3.5.3",
+  "version": "3.6.1",
   "description": "MCP Server for querying server logs via SSH jump host and Grafana Loki API",
   "main": "index.js",
   "type": "module",

package/ssh-client.js

@@ -35,9 +35,13 @@ const _sshSem = {
 /**
  * 获取 SSH 信号量槽位
  * @param {number} [timeoutMs] - 排队超时（默认 60s），防止无限等
+ * @param {AbortSignal} [signal] - 用户 cancel 信号，abort 时立即从队列移除并 reject
  * @returns {Promise<void>}
  */
-function sshAcquire(timeoutMs = SSH_ACQUIRE_TIMEOUT) {
+function sshAcquire(timeoutMs = SSH_ACQUIRE_TIMEOUT, signal) {
+  if (signal && signal.aborted) {
+    return Promise.reject(new Error('CANCELLED before SSH acquire'));
+  }
   if (_sshSem.active < _sshSem.max) {
     _sshSem.active++;
     log(`[SSH-Sem] acquire 直接通过 (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
@@ -49,10 +53,15 @@ function sshAcquire(timeoutMs = SSH_ACQUIRE_TIMEOUT) {
   log(`[SSH-Sem] acquire 进入排队 (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length + 1}, timeout=${timeoutMs}ms)`);
   return new Promise((resolve, reject) => {
     let settled = false;
+    let onAbort;
+    const cleanup = () => {
+      clearTimeout(timer);
+      if (signal && onAbort) signal.removeEventListener('abort', onAbort);
+    };
     const enterQueue = () => {
-      if (settled) return; // 已超时，放弃并立刻腾位给下一个
+      if (settled) return; // 已超时/已取消，放弃并立刻腾位给下一个
       settled = true;
-      clearTimeout(timer);
+      cleanup();
       _sshSem.active++;
       log(`[SSH-Sem] acquire 出队获得槽位 (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
       resolve();
@@ -61,12 +70,23 @@ function sshAcquire(timeoutMs = SSH_ACQUIRE_TIMEOUT) {
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
-      // 从队列里移除自己的 entry
+      cleanup();
       const idx = _sshSem.queue.indexOf(enterQueue);
       if (idx >= 0) _sshSem.queue.splice(idx, 1);
       log(`[SSH-Sem] acquire 排队超时 (${timeoutMs}ms, active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
       reject(new Error(`SSH 排队等待超时 (${timeoutMs}ms)：前面请求卡住，或并发过高。可调整 SSH_MAX_CONCURRENT / SSH_ACQUIRE_TIMEOUT`));
     }, timeoutMs);
+    // 用户 cancel：立即从队列移除
+    onAbort = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      const idx = _sshSem.queue.indexOf(enterQueue);
+      if (idx >= 0) _sshSem.queue.splice(idx, 1);
+      log(`[SSH-Sem] acquire 用户 cancel，从队列移除 (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
+      reject(new Error('CANCELLED in SSH queue'));
+    };
+    if (signal) signal.addEventListener('abort', onAbort, { once: true });
   });
 }
 
@@ -87,8 +107,9 @@ function sshRelease() {
  */
 export async function queryLog(service, command, options = {}) {
   const timeout = options.timeout || DEFAULTS.timeout;
+  const signal = options.signal;
 
-  await sshAcquire();
+  await sshAcquire(undefined, signal);
   try {
     return await new Promise((resolve, reject) => {
     const conn = new Client();
@@ -108,6 +129,20 @@ export async function queryLog(service, command, options = {}) {
       }
     }, timeout);
 
+    // 用户 cancel：立即 destroy 连接
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      log(`[SSH] ⊗ 用户 cancel，destroy 连接 (${service.name})`);
+      try { conn.destroy(); } catch {};
+      reject(new Error('CANCELLED during SSH'));
+    };
+    if (signal) {
+      if (signal.aborted) { onAbort(); return; }
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+
     conn.on('ready', () => {
       conn.shell({ term: 'xterm', rows: 24, cols: 500 }, (err, stream) => {
         if (err) {
@@ -267,8 +302,9 @@ export async function testConnection() {
  */
 export async function executeKubectl(kubectlCommand, options = {}) {
   const timeout = options.timeout || DEFAULTS.timeout;
+  const signal = options.signal;
 
-  await sshAcquire();
+  await sshAcquire(undefined, signal);
   try {
     return await new Promise((resolve, reject) => {
     const conn = new Client();
@@ -288,6 +324,20 @@ export async function executeKubectl(kubectlCommand, options = {}) {
       }
     }, timeout);
 
+    // 用户 cancel：立即 destroy 连接
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      log(`[SSH] ⊗ 用户 cancel，destroy 连接 (kubectl: ${kubectlCommand.substring(0, 50)}...)`);
+      try { conn.destroy(); } catch {};
+      reject(new Error('CANCELLED during kubectl'));
+    };
+    if (signal) {
+      if (signal.aborted) { onAbort(); return; }
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+
     conn.on('ready', () => {
       conn.shell({ term: 'xterm', rows: 24, cols: 500 }, (err, stream) => {
         if (err) {