beacon-mfg-mcp 1.4.0 → 1.4.2

package/RELEASE.md

@@ -1,4 +1,4 @@
-# Beacon-MFG 只读 MCP 服务 · v1.3.3
+# Beacon-MFG 只读 MCP 服务 · v1.4.2
 
 让任意支持 MCP 的主流 agent（Claude Desktop / Cline / Continue / WorkBuddy 等）能够
 **检索与调用**已发布到 Cloudflare Pages（或 GitHub）的灯塔工厂供应商数据，
@@ -21,7 +21,23 @@ MCP 只做**只读检索**。后端数据采集、英文翻译、库维护等流
 后三个构成「采购寻源」多轮会话链路 `start_sourcing → answer_sourcing → refine_sourcing`，
 依赖仓库平级的 `skills/rfq-kernel` 桥接模块。
 
-## 本次更新（v1.3.3）
+## 本次更新（v1.4.2）
+- **自动升级（自更新）**：新增 `bin/selfupdate.js`，MCP 启动时以**独立 detached 子进程**拉起（绝不阻塞 MCP 启动），
+  节流查 npm registry `latest`（默认 24h 一次，可用 `BEACON_MCP_UPDATE_INTERVAL_H` 调），发现新版本即执行
+  `npm i -g beacon-mfg-mcp@<新版本>`（Windows 上正确走 `npm.cmd + shell`）。
+- **跳过条件**：设 `BEACON_MCP_NO_UPDATE=1`、或已设 `BEACON_SOURCE` / `BEACON_REPO`（离线 / 本地仓库用户）时**不联网升级**，避免对本地仓库用户添乱。
+- **并发保护**：原子目录锁 + 残留锁 10 分钟过期自愈（踩过死锁坑——残留锁会让之后所有启动永久跳过自更新）。
+- **测试**：`test_update.js` 单元测试 23/23 通过，并以 fake-npm 拦截验证安装命令形态正确（`npm.cmd i -g beacon-mfg-mcp@1.4.2`）。
+- **前向生效说明**：自更新是「向前生效」的——已装的 ≤1.4.1 旧版代码里没有 `selfupdate.js`，需**一次性手动** `npm i -g beacon-mfg-mcp@latest` 进入自动升级基线；之后永久自动。`npx beacon-mfg-mcp` 用户天然永远最新。
+
+## 本次更新（v1.4.1，已发布）
+- **直连优先 + 死代理容错**：修复「失效代理导致检索归零」——默认源不可达时直连兜底镜像，且报错信息直指真因（是代理挂了而非数据问题），`npm i -g` 装一次即享受（无需重启客户端）。
+
+## 本次更新（v1.4.0，已发布）
+- **标准分帧适配层 `mcp_adapter.py`**：补齐「严格分帧」客户端接入路径，与「换行 stdio」「Streamable HTTP」三条传输链路统一。
+- **协议回归测试 `test_protocol.py`**：一条命令覆盖三条链路（握手 + 6 工具齐全 + 三城市真实检索 `via_index`），发版前必跑。
+
+## 本次更新（v1.3.3，已发布）
 - **本地检索免提交、免重启即时可见**：这是 v1.3.1「worktree 兜底」的收尾。v1.3.1 只让**单文件读**走了工作树，
   但关键词/城市检索的**召回**走的是**批量读** `_read_many_text()`——它在 git 模式下恒走 `git archive HEAD`
   （已提交快照），于是**改完数据、重建索引后，关键词检索仍读旧索引、必须 commit 才可见**。
@@ -54,7 +70,7 @@ MCP 只做**只读检索**。后端数据采集、英文翻译、库维护等流
 ## 安装（三选一）
 
 ### 1. 从 GitHub Release 下载（推荐，零依赖）
-下载本 Release 的 `beacon-mfg-mcp-mcp-v1.3.3.tar.gz`，解压后：
+下载本 Release 的 `beacon-mfg-mcp-mcp-v1.4.2.tar.gz`，解压后：
 ```jsonc
 {
   "mcpServers": {

package/bin/beacon-mfg-mcp.js

@@ -1,11 +1,29 @@
 #!/usr/bin/env node
 'use strict';
 // beacon-mfg-mcp 启动器：本 MCP 服务是纯 Python 标准库实现，这里只负责
-// 在用户机器上找到 Python 解释器并拉起 server.py（stdio 协议）。
-const { spawnSync } = require('child_process');
+// ① 在用户机器上找到 Python 解释器并拉起 server.py（stdio 协议）
+// ② 顺手踢一个**独立进程**去做节流的自更新检查
+const { spawnSync, spawn } = require('child_process');
 const path = require('path');
 
 const serverPy = path.join(__dirname, '..', 'server.py');
+const selfUpdateJs = path.join(__dirname, 'selfupdate.js');
+
+// 踢起自更新检查：detached + unref，主进程既不等它也不被它拖住。
+// 为什么必须是独立进程而不是本进程里的 async 函数：
+// 下面 spawnSync 是**同步阻塞**的，会冻结整个事件循环 —— async 的自更新
+// 在 server 运行期间推不动，等它能跑时本进程已经 process.exit() 了，
+// 更新逻辑永远跑不完（实测 stamp 根本不写）。独立进程不受此影响。
+// 失败、离线、没权限一律静默：它只影响「下次启动是不是最新版」。
+try {
+  const u = spawn(process.execPath, [selfUpdateJs], {
+    stdio: 'ignore',
+    detached: true,
+    windowsHide: true,
+  });
+  u.on('error', () => { /* 没有 node？不可能，自身就是 node 起的 */ });
+  u.unref();
+} catch (_) { /* 自更新是加分项，绝不能影响 MCP 启动 */ }
 
 // 探测可用的 Python 解释器（优先 python3，兼容 python / py）
 const candidates = ['python3', 'python', 'py'];

package/bin/selfupdate.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+'use strict';
+// beacon-mfg-mcp 自更新检查（独立进程，由 launcher 以 detached 方式拉起）
+//
+// 【为什么必须独立成进程】
+// launcher 用 spawnSync 同步拉起 server.py —— 那会**阻塞 Node 整个事件循环**。
+// 如果把自更新写成 async 函数在主进程里跑，它在 spawnSync 期间推不动，
+// 等 server 退出、事件循环恢复时，主进程紧跟着就 process.exit() 了，
+// 于是更新逻辑永远跑不完（实测：stamp 根本没写）。
+// 独立 detached 子进程不受主进程阻塞与退出影响，是唯一稳的做法。
+//
+// 【三条硬约束】
+//   1. 绝不阻塞 MCP 启动：本进程是 detached + unref 的，主进程不等它。
+//   2. 失败一律静默降级：离线 / 内网 / 没装 npm / 无写权限，都只当没更新过。
+//   3. 节流 + 可关：默认 24h 查一次；BEACON_MCP_NO_UPDATE=1 完全关闭。
+
+const { spawnSync, spawn } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const https = require('https');
+
+const PKG = require('../package.json');
+const CURRENT = PKG.version || '0.0.0';
+
+const STATE_DIR = path.join(os.homedir() || '.', '.beacon-mfg');
+const STAMP = path.join(STATE_DIR, 'update-check.json');
+const LOCK = path.join(STATE_DIR, 'update.lock');
+const REGISTRY = 'https://registry.npmjs.org/beacon-mfg-mcp/latest';
+const INTERVAL_H = Number(process.env.BEACON_MCP_UPDATE_INTERVAL_H || 24);
+
+function note(msg) {
+  // 只能写 stderr：stdout 可能是 MCP 协议通道（在独立进程里虽然安全，
+  // 但保持一致，将来若被复用也不会误伤）。
+  try { process.stderr.write('[beacon-mfg-mcp] ' + msg + '\n'); } catch (_) {}
+}
+
+function semverGt(a, b) {
+  const pa = String(a).split('.').map((x) => parseInt(x, 10) || 0);
+  const pb = String(b).split('.').map((x) => parseInt(x, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return true;
+    if ((pa[i] || 0) < (pb[i] || 0)) return false;
+  }
+  return false;
+}
+
+function shouldSkip() {
+  if (process.env.BEACON_MCP_NO_UPDATE === '1') return true;
+  // 离线仓库用户（数据来自本地 git/目录），联网升级只会添乱
+  if (process.env.BEACON_SOURCE || process.env.BEACON_REPO) return true;
+  return false;
+}
+
+function readStamp() {
+  try { return JSON.parse(fs.readFileSync(STAMP, 'utf8')).ts || 0; } catch (_) { return 0; }
+}
+function writeStamp(extra) {
+  try {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    fs.writeFileSync(STAMP, JSON.stringify(
+      Object.assign({ ts: Date.now(), version: CURRENT }, extra || {})));
+  } catch (_) {}
+}
+// 锁的过期时间：超过就视为持有者已死，直接接管。
+// 为什么必须有：detached 子进程有可能被中途杀掉（launcher 退出、Windows job object），
+// 停在「已加锁、未解锁」之间。实测踩到过一次 —— 残留锁会让**此后所有启动**
+// 永久跳过自更新，而且现场毫无线索。所以锁必须能自愈。
+const LOCK_STALE_MS = Number(process.env.BEACON_MCP_UPDATE_LOCK_STALE_MIN || 10) * 60000;
+
+function lockHeld() {
+  // flag 'wx' = 原子创建，文件已存在会抛错。用 writeFileSync 覆盖写是**不互斥**的
+  // （两个进程都会「拿到锁」然后互相 unlink），并发保护就成了摆设。
+  const grab = () => {
+    const fd = fs.openSync(LOCK, 'wx');
+    fs.writeSync(fd, String(process.pid) + ' ' + Date.now());
+    fs.closeSync(fd);
+  };
+  try {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    grab();
+    return true;
+  } catch (_) {
+    try {
+      const st = fs.statSync(LOCK);
+      if (Date.now() - st.mtimeMs > LOCK_STALE_MS) {
+        fs.unlinkSync(LOCK);      // 持有者已死，回收
+        grab();
+        return true;
+      }
+    } catch (_) { /* 回收也失败：只当没拿到锁 */ }
+    return false;
+  }
+}
+function unlock() {
+  try { fs.unlinkSync(LOCK); } catch (_) {}
+}
+
+function fetchLatest(timeoutMs) {
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (v) => { if (!done) { done = true; resolve(v); } };
+    let req;
+    try {
+      req = https.get(REGISTRY, { headers: { Accept: 'application/json' } },
+        (r) => {
+          if (r.statusCode !== 200) { r.resume(); return finish(null); }
+          let b = '';
+          r.setEncoding('utf8');
+          r.on('data', (c) => { b += c; if (b.length > 20000) r.destroy(); });
+          r.on('end', () => {
+            try { finish(JSON.parse(b).version || null); } catch (_) { finish(null); }
+          });
+        });
+    } catch (_) { return finish(null); }
+    req.setTimeout(timeoutMs, () => { try { req.destroy(); } catch (_) {} finish(null); });
+    req.on('error', () => finish(null));
+  });
+}
+
+const IS_WIN = process.platform === 'win32';
+// Windows 上 npm 是 npm.cmd 批处理，必须 shell:true，否则 FileNotFoundError。
+const NPM = IS_WIN ? 'npm.cmd' : 'npm';
+const NPM_OPTS = { stdio: 'ignore', shell: IS_WIN, env: process.env };
+
+async function main() {
+  if (shouldSkip()) return;
+  if (Date.now() - readStamp() < INTERVAL_H * 3600 * 1000) return;  // 节流
+  if (!lockHeld()) return;                                          // 并发保护
+
+  const latest = await fetchLatest(5000);
+  if (!latest) { writeStamp({ result: 'registry_unreachable' }); unlock(); return; }
+  writeStamp({ result: 'checked', latest });
+  if (!semverGt(latest, CURRENT)) { unlock(); return; }              // 已最新
+
+  note('发现新版 ' + latest + '（当前 ' + CURRENT + '），正在更新…');
+  // 同步等安装结果：detached 进程本身就是后台的，这里等一会儿无副作用，
+  // 换来的是能把「成功/失败」明确告诉用户。
+  const r = spawnSync(NPM, ['i', '-g', 'beacon-mfg-mcp@' + latest],
+    Object.assign({ timeout: 180000 }, NPM_OPTS));
+  unlock();
+  if (r.status === 0) {
+    note('已更新 ' + CURRENT + ' → ' + latest + '，下次启动生效。');
+  } else {
+    note('自动更新未成功（可能缺权限或网络受限）。'
+       + '可手动执行：npm i -g beacon-mfg-mcp@latest');
+  }
+}
+
+main().catch(() => { unlock(); process.exit(0); });

package/package.json

@@ -1,44 +1,44 @@
-{
-  "name": "beacon-mfg-mcp",
-  "version": "1.4.0",
-  "description": "Read-only MCP server exposing the BeaconMFG灯塔工厂 supplier directory (search vendors, get vendor detail, get capability card, multi-turn sourcing) to any MCP-compatible agent. No API key required.",
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "beacon-mfg",
-    "suppliers",
-    "manufacturing",
-    "china",
-    "sourcing"
-  ],
-  "homepage": "https://github.com/eiry16/beacon-mfg#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/eiry16/beacon-mfg.git"
-  },
-  "bugs": {
-    "url": "https://github.com/eiry16/beacon-mfg/issues"
-  },
-  "license": "MIT",
-  "bin": {
-    "beacon-mfg-mcp": "bin/beacon-mfg-mcp.js"
-  },
-  "files": [
-    "server.py",
-    "http_server.py",
-    "mcp_adapter.py",
-    "test_protocol.py",
-    "bin/",
-    "rfq-kernel/",
-    "copy-rfk.js",
-    "README.md",
-    "RELEASE.md"
-  ],
-  "scripts": {
-    "prepack": "node copy-rfk.js"
-  },
-  "engines": {
-    "node": ">=16"
-  },
-  "dependencies": {}
-}
+{
+  "name": "beacon-mfg-mcp",
+  "version": "1.4.2",
+  "description": "Read-only MCP server exposing the BeaconMFG灯塔工厂 supplier directory (search vendors, get vendor detail, get capability card, multi-turn sourcing) to any MCP-compatible agent. No API key required.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "beacon-mfg",
+    "suppliers",
+    "manufacturing",
+    "china",
+    "sourcing"
+  ],
+  "homepage": "https://github.com/eiry16/beacon-mfg#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eiry16/beacon-mfg.git"
+  },
+  "bugs": {
+    "url": "https://github.com/eiry16/beacon-mfg/issues"
+  },
+  "license": "MIT",
+  "bin": {
+    "beacon-mfg-mcp": "bin/beacon-mfg-mcp.js"
+  },
+  "files": [
+    "server.py",
+    "http_server.py",
+    "mcp_adapter.py",
+    "test_protocol.py",
+    "bin/",
+    "rfq-kernel/",
+    "copy-rfk.js",
+    "README.md",
+    "RELEASE.md"
+  ],
+  "scripts": {
+    "prepack": "node copy-rfk.js"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "dependencies": {}
+}

package/server.py

@@ -43,6 +43,7 @@ import time
 import hmac
 import urllib.request
 import urllib.error
+import socket
 from typing import Any, Dict, List, Optional, Tuple
 import sys as _sys
 import uuid as _uuid
@@ -270,9 +271,9 @@ def _pkg_version() -> str:
     try:
         p = os.path.join(os.path.dirname(os.path.abspath(__file__)), "package.json")
         with open(p, "r", encoding="utf-8") as f:
-            return json.load(f).get("version", "1.3.3")
+            return json.load(f).get("version", "1.4.2")
     except Exception:
-        return "1.3.3"
+        return "1.4.2"
 
 
 # HTTP 基址列表（含兜底镜像）。默认部署 Cloudflare Pages 不可达时，自动回退到
@@ -450,11 +451,74 @@ def _git_show(relpath: str) -> Optional[str]:
 _HTTP_TIMEOUT = 15
 
 
+# 记录最近一次全失败的诊断（供上层报错时引用，不进返回值以免破坏既有签名）
+_HTTP_LAST_ERROR: List[str] = [""]
+
+
+def _openers() -> List[Tuple[str, Any]]:
+    """构造 (标签, opener) 列表，**直连优先、代理兜底**。
+
+    为什么需要：urllib 默认读取环境里的 `*_proxy` 变量。客户机器上若配了
+    已失效的代理（VPN/Clash 退出、端口已关），所有请求都会被代理吃掉并失败，
+    表现为「无法取得 manifest.json」——报错完全没指向真因，客户无从下手。
+    这里把「绕过代理直连」作为**第一选择**，代理仅作兜底，并在全部失败时
+    给出明确诊断（见 `_http_diagnose`）。
+
+    仅在直连确实失败后才启用代理，因此不会破坏内网/反代等必须走代理的场景。
+    """
+    out: List[Tuple[str, Any]] = []
+    # 1) 直连（显式 no-proxy opener，忽略环境里的 *_proxy）
+    try:
+        out.append(("direct", urllib.request.build_opener(urllib.request.ProxyHandler({}))))
+    except Exception:
+        pass
+    # 2) 环境代理（若系统确实配置了可用代理，这里才会成功）
+    try:
+        if urllib.request.getproxies():
+            out.append(("proxy", urllib.request.build_opener()))
+    except Exception:
+        pass
+    # 3) 兜底：默认 opener
+    if not out:
+        out.append(("default", urllib.request.build_opener()))
+    return out
+
+
+def _http_diagnose(relpath: str, last_err: str = "") -> str:
+    """全部基址+全部连接方式都失败时，给出**指向真因**的诊断串。"""
+    hints = []
+    try:
+        proxies = urllib.request.getproxies()
+    except Exception:
+        proxies = {}
+    live = []
+    for k, v in proxies.items():
+        try:
+            host = v.split("//")[-1].split(":")[0].split("@")[-1]
+            port = v.rsplit(":", 1)[-1].split("/")[0]
+            s = socket.create_connection((host, int(port)), timeout=1.5)
+            s.close()
+            live.append("%s=%s" % (k, v))
+        except Exception:
+            hints.append("代理 %s=%s **不可用**（已退出/端口未监听）" % (k, v))
+    if live:
+        hints.append("可用代理: " + ", ".join(live))
+    if not hints:
+        hints.append("未检测到代理配置；可能是本机网络不可达或域名被阻断")
+    if last_err:
+        hints.append("最后错误: " + last_err)
+    return "；".join(hints)
+
+
 def _http_get(relpath: str) -> Tuple[Optional[str], Optional[str]]:
     """统一的 HTTP 读取：依次尝试 _http_bases() 中的基址（主源 + 兜底镜像），
-    任一成功即返回；全部失败则用本地缓存兜底（保证离线可用）。"""
+    任一成功即返回；全部失败则用本地缓存兜底（保证离线可用）。
+
+    连接方式上「直连优先、代理兜底」——避免失效代理把检索整体打挂。
+    """
     cached_body = None
     cached_etag = None
+    last_err = ""
     for base in _http_bases():
         url = base + "/" + relpath
         cap = _cache_path(url)
@@ -478,26 +542,29 @@ def _http_get(relpath: str) -> Tuple[Optional[str], Optional[str]]:
         req = urllib.request.Request(url, headers=headers)
         if etag:
             req.add_header("If-None-Match", etag)
-        try:
-            resp = urllib.request.urlopen(req, timeout=_HTTP_TIMEOUT)
-            body = resp.read().decode("utf-8")
-            new_etag = resp.headers.get("ETag")
+        for _tag, opener in _openers():
             try:
-                with open(cap, "w", encoding="utf-8") as f:
-                    json.dump({"etag": new_etag, "body": body}, f)
-            except Exception:
-                pass
-            return body, new_etag
-        except urllib.error.HTTPError as e:
-            if e.code == 304 and cached_body is not None:
-                return cached_body, etag
-            continue
-        except Exception:
-            # 当前基址不可达：尝试下一个兜底镜像；全部失败后在末尾用本地缓存兜底
-            continue
+                resp = opener.open(req, timeout=_HTTP_TIMEOUT)
+                body = resp.read().decode("utf-8")
+                new_etag = resp.headers.get("ETag")
+                try:
+                    with open(cap, "w", encoding="utf-8") as f:
+                        json.dump({"etag": new_etag, "body": body}, f)
+                except Exception:
+                    pass
+                return body, new_etag
+            except urllib.error.HTTPError as e:
+                if e.code == 304 and cached_body is not None:
+                    return cached_body, etag
+                last_err = "HTTP %s" % e.code
+                break   # HTTP 层错误，换基址比重试连接方式有意义
+            except Exception as e:
+                last_err = "%s: %s" % (type(e).__name__, e)
+                continue   # 连接层失败（典型：代理不可用）→ 换连接方式
     # 全部基址失败：若有任何本地缓存也返回，保证离线可用
     if cached_body is not None:
         return cached_body, cached_etag
+    _HTTP_LAST_ERROR[0] = _http_diagnose(relpath, last_err)
     return None, None
 
 
@@ -565,7 +632,15 @@ def load_manifest() -> Dict[str, Any]:
     if _cache_stale(_manifest_cache, "data/manifest.json"):
         txt = fetch_text("data/manifest.json")
         if not txt:
-            raise RuntimeError("无法取得 manifest.json（检查 BEACON_SOURCE / BEACON_REPO / 网络）")
+            # 报错必须指向真因：把 _http_get 记下的连接层诊断（失效代理 / 网络不可达 /
+            # 域名阻断）带上，否则客户只看到「检查网络」却无从下手。
+            detail = _HTTP_LAST_ERROR[0] or "无缓存且所有镜像均不可达"
+            raise RuntimeError(
+                "无法取得 manifest.json。诊断：" + detail
+                + "。可尝试：① 检查系统代理/VPN 是否已退出或端口未监听；"
+                + "② 设置 BEACON_SOURCE 指向自建镜像；"
+                + "③ 设置 BEACON_REPO 指向本地仓库以完全离线使用。"
+            )
         _manifest_cache = (json.loads(txt), time.time(), _wt_mtime("data/manifest.json"))
     return _manifest_cache[0]
 

package/test_protocol.py

@@ -233,6 +233,56 @@ def test_adapter():
             proc.kill()
 
 
+def test_dead_proxy():
+    """死代理容错：环境里配了**不可用**代理时，仍应直连成功（回归 #100086）。
+
+    背景：客户机器上若配了已失效的代理（VPN/Clash 退出、端口已关），
+    urllib 会把所有请求喂给死代理 → 检索整体归零，且旧报错「检查网络」不指向真因。
+    修法见 server.py 的 `_openers()`：直连优先、代理兜底。
+    """
+    print("\n[*] 死代理容错  (直连优先)")
+    env = _child_env()
+    env.pop("BEACON_REPO", None)          # 强制走联网，才能真正触发网络取数
+    for k in ("http_proxy", "https_proxy", "HTTP_PROXY", "HTTPS_PROXY"):
+        env[k] = "http://127.0.0.1:9"     # 9 = discard 端口，几乎必然拒绝
+    env["BEACON_MIRRORS"] = ""             # 别被本地镜像配置干扰
+    proc = subprocess.Popen([sys.executable, "-u", SERVER], stdin=subprocess.PIPE,
+                            stdout=subprocess.PIPE, env=env, encoding="utf-8", bufsize=1)
+    try:
+        def send(method, params, notify=False):
+            msg = {"jsonrpc": "2.0", "method": method, "params": params}
+            if not notify:
+                msg["id"] = 1
+            else:
+                msg.pop("id", None)
+            proc.stdin.write(json.dumps(msg, ensure_ascii=False) + "\n")
+            proc.stdin.flush()
+            if notify:
+                return None
+            return json.loads(proc.stdout.readline())
+
+        send("initialize", {"protocolVersion": "2024-11-05", "capabilities": {},
+                            "clientInfo": {"name": "smoke", "version": "1"}})
+        send("notifications/initialized", {}, notify=True)
+        r = send("tools/call", {"name": "search_vendors",
+                                "arguments": {"query": "面馆", "city": "苏州", "limit": 3}})
+        n, err = 0, ""
+        if r and "result" in r:
+            try:
+                n = len(json.loads(r["result"]["content"][0]["text"]).get("results", []))
+            except Exception as e:
+                err = "解析失败 %s" % e
+        else:
+            err = "无回包（很可能被死代理拖累）"
+        _check("dead-proxy 苏州/面馆", n > 0, err or "命中 %d" % n)
+    finally:
+        proc.terminate()
+        try:
+            proc.wait(timeout=5)
+        except Exception:
+            proc.kill()
+
+
 def main():
     print("=" * 60)
     print("BeaconMFG MCP 协议回归测试")
@@ -247,6 +297,7 @@ def main():
     else:
         print("\n[2/3] stdio  (跳过，加 --stdio 启用)")
         print("[3/3] adapter (跳过，加 --adapter 启用)")
+    test_dead_proxy()
 
     passed = sum(1 for _, ok, _ in _results if ok)
     failed = [(n, d) for n, ok, d in _results if not ok]