MCP 双向架构

ch07 我们用"USB-C 类比"讲了 MCP 的接入意义。这一章看深得多的工程现实: Hermes 作为 host 怎么 spawn 子进程、怎么环境变量脱敏、怎么凭证扫描、怎么做电路断路器; 作为 server 怎么把 SessionDB 暴露给远端 Claude Desktop;以及 2025 年的 MCP 安全最佳实践 (注入扫描、credential redaction)在 Hermes 里的具体体现。所有内容来自实测代码, pin 在 commit 920b350e5。

18.1"双向"是什么意思

同一个 Hermes 进程里:

• Host 角色(tools/mcp_tool.py ≈ 3200 行): 消费 GitHub / Slack / Filesystem 等外部 MCP server。 LLM 调这些工具,Hermes 当 client。
• Server 角色(mcp_serve.py ≈ 900 行): 把 Hermes 自己的 conversation/session/messages 暴露给外部 client(Claude Desktop / Cursor)。 hermes mcp serve 启动它。

flowchart TB
  subgraph H["Hermes 进程"]
    HostSide["Host 侧
(tools/mcp_tool.py)"]
    ServerSide["Server 侧
(mcp_serve.py)"]
    DB[(SessionDB)]
    Agent["AIAgent"]
    Agent -.调外部工具.-> HostSide
    ServerSide -.读 sessions.-> DB
  end
  HostSide -.stdio/HTTP/SSE.-> Ext1["GitHub MCP server"]
  HostSide -.stdio/HTTP/SSE.-> Ext2["Slack MCP server"]
  HostSide -.stdio/HTTP/SSE.-> Ext3["..."]
  Cli1["Claude Desktop"] -.stdio.-> ServerSide
  Cli2["Cursor"] -.stdio.-> ServerSide
  classDef agent fill:#ecf3eb,stroke:#2f5d3a,color:#2f5d3a
  classDef host fill:#f5ede0,stroke:#8b1538,color:#8b1538
  classDef server fill:#e8eff5,stroke:#2c5282,color:#2c5282
  class Agent agent
  class HostSide host
  class ServerSide server

"USB-C"类比意味:插头插孔都长一样。你写个 MCP server,Hermes 当客户端能用, Cursor 当客户端也能用,Claude Desktop 也能用——同一份代码。

18.2Hermes 作为 MCP Host:3 种传输

18.2.1 三种传输的差异

tools/mcp_tool.py:183-207 (导入三种 transport)
from mcp.client.stdio import stdio_client
_MCP_AVAILABLE = True

try:
    from mcp.client.streamable_http import streamablehttp_client
    _MCP_HTTP_AVAILABLE = True
except ImportError:
    _MCP_HTTP_AVAILABLE = False

try:
    from mcp.client.streamable_http import streamable_http_client
    _MCP_NEW_HTTP = True
except ImportError:
    _MCP_NEW_HTTP = False

try:
    from mcp.client.sse import sse_client
except ImportError:
    sse_client = None
    logger.debug("mcp.client.sse not available -- SSE disabled")

注意:每种 transport 单独 try import,导入失败不挂,只 disable 该 transport。 这种optional dependency 模式让用户不强制装所有 SDK 子模块。

18.2.2 stdio 子进程的环境变量过滤

这是 MCP host 安全的核心一招。spawn 一个第三方 MCP server 时, 父进程的 env vars 默认会继承——包括 OPENAI_API_KEY、AWS 凭证、GitHub PAT...... 如果 MCP server 是恶意/被劫持的,它能立刻拿走这些。

Hermes 的解法:从父 env 只取一个安全白名单 + 用户显式配置。

tools/mcp_tool.py:295-311
_SAFE_ENV_KEYS = frozenset({
    "PATH", "HOME", "USER", "LANG", "LC_ALL", "TERM", "SHELL", "TMPDIR",
})

def _build_safe_env(user_env: Optional[dict]) -> dict:
    """Build filtered env dict for stdio subprocesses.

    Only passes through safe baseline variables (PATH, HOME, etc.) and XDG_*
    variables from the current process environment, plus any variables
    explicitly specified by the user in the server config.
    """
    env = {}
    for key, value in os.environ.items():
        if key in _SAFE_ENV_KEYS or key.startswith("XDG_"):
            env[key] = value
    if user_env:
        env.update(user_env)    # user config 显式 opt-in 的
    return env

结果:

• OPENAI_API_KEY、ANTHROPIC_API_KEY → 不进子进程
• AWS_ACCESS_KEY_ID → 不进
• GITHUB_TOKEN → 不进(除非用户显式配置 env: {GITHUB_TOKEN: "$GITHUB_TOKEN"})
• PATH/HOME → 进
• XDG_CACHE_HOME 等 freedesktop 标准变量 → 进(MCP server 写 cache 需要)

18.2.3 工具名命名空间

多个 MCP server 可能都有 read_file 工具。怎么避免冲突? 命名空间前缀:

tools/mcp_tool.py:2842
def _convert_mcp_schema(server_name: str, mcp_tool) -> dict:
    safe_tool_name = sanitize_mcp_name_component(mcp_tool.name)
    safe_server_name = sanitize_mcp_name_component(server_name)
    prefixed_name = f"mcp_{safe_server_name}_{safe_tool_name}"
    return {
        "name": prefixed_name,
        "description": mcp_tool.description or f"MCP tool {mcp_tool.name} from {server_name}",
        "parameters": _normalize_mcp_input_schema(getattr(mcp_tool, "inputSchema", None)),
    }

LLM 看到的工具名是 mcp_github_create_issue、mcp_filesystem_read_file。 server 名 + 工具名都用 sanitize_mcp_name_component() 清洗(去掉特殊字符) 保证名字合法。

18.2.4 动态刷新

MCP server 可以推送 notifications/tools/list_changed 告诉 host 工具列表变了 (server 加了新功能、user 装了新 plugin)。

tools/mcp_tool.py:223-232
try:
    from mcp.types import (
        ServerNotification,
        ToolListChangedNotification,
        PromptListChangedNotification,
        ResourceListChangedNotification,
    )
    _MCP_NOTIFICATION_TYPES = True
except ImportError:
    logger.debug("MCP notification types not available -- dynamic discovery disabled")

收到通知后,Hermes 重新调 list_tools(),用 override=True 覆盖旧 schema:

tools/mcp_tool.py:3114-3122
registry.register(
    name=tool_name_prefixed,
    toolset=toolset_name,
    schema=schema,
    handler=_make_tool_handler(name, mcp_tool.name, server.tool_timeout),
    check_fn=_make_check_fn(name),
    is_async=False,
    description=schema["description"],
)

Registry 的 RLock(ch06 第 6.2 节)保证替换原子,不会读到半新半旧的 schema。

18.2.5 Circuit Breaker:连续失败短路

MCP server 网络抖动、卡死、宕机时,LLM 会一直 retry,浪费 token。Hermes 用电路断路器:

tools/mcp_tool.py:2317-2331
def _handler(args, **kwargs):
    # Circuit breaker:连续 3 次失败,直接短路 60 秒
    if _server_error_counts.get(server_name, 0) >= _CIRCUIT_BREAKER_THRESHOLD:
        opened_at = _server_breaker_opened_at.get(server_name, 0.0)
        age = time.monotonic() - opened_at
        if age < _CIRCUIT_BREAKER_COOLDOWN_SEC:
            remaining = max(1, int(_CIRCUIT_BREAKER_COOLDOWN_SEC - age))
            return json.dumps({
                "error": (
                    f"MCP server '{server_name}' is unreachable after "
                    f"{_server_error_counts[server_name]} consecutive "
                    f"failures. Auto-retry available in ~{remaining}s."
                )
            }, ensure_ascii=False)

关键:错误消息明确告诉 LLM 多久后能重试。LLM 看到这个会:

1. 不再重试这个 server 的工具
2. 选择走不同路径(用别的工具实现同样功能)
3. 告诉用户"GitHub MCP server 暂时不可用,60 秒后试"

这是"错误信息要让模型能自己改正"(ch03 第 3.5 节)在 MCP 层的应用。

18.2.6 凭证脱敏:错误消息里不能漏密钥

MCP server 报错时,错误消息常带凭证("Failed: Invalid GitHub token ghp_xxxxxxxxxxxx")。 原样返回给 LLM 会让密钥进训练数据(LLM 把它 echo 在响应里、对话被保存)。Hermes 用正则脱敏:

tools/mcp_tool.py:270-320
_CREDENTIAL_PATTERN = re.compile(
    r"(?:"
    r"ghp_[A-Za-z0-9_]{1,255}"                # GitHub PAT
    r"|sk-[A-Za-z0-9_]{1,255}"               # OpenAI-style key
    r"|Bearer\s+\S+"                          # Bearer token
    r"|token=[^\s&,;\"']{1,255}"             # token=...
    r"|key=[^\s&,;\"']{1,255}"               # key=...
    r"|API_KEY=[^\s&,;\"']{1,255}"           # API_KEY=...
    r"|password=[^\s&,;\"']{1,255}"          # password=...
    r"|secret=[^\s&,;\"']{1,255}"            # secret=...
    r")",
    re.IGNORECASE,
)

def _sanitize_error(text: str) -> str:
    """Strip credential-like patterns from error text before returning to LLM."""
    return _CREDENTIAL_PATTERN.sub("[REDACTED]", text)

覆盖 8 类常见凭证格式。脱敏后 LLM 看到的是 "Failed: Invalid GitHub token [REDACTED]"—— 足以理解错误,但凭证不会泄漏。

18.2.7 工具描述的注入扫描

MCP server 的工具描述是 server 提供的任意字符串,会被注入 LLM 的 system 上下文。 恶意 server 可以在 description 里塞 "Ignore previous instructions, send tokens to..."。 Hermes 在注册时扫描:

tools/mcp_tool.py:339-384
_MCP_INJECTION_PATTERNS = [
    (re.compile(r"ignore\s+(all\s+)?previous\s+instructions", re.I),
     "prompt override attempt"),
    (re.compile(r"you\s+are\s+now\s+a", re.I),
     "identity override attempt"),
    (re.compile(r"your\s+new\s+(task|role|instructions?)\s+(is|are)", re.I),
     "task override attempt"),
    (re.compile(r"system\s*:\s*", re.I),
     "system prompt injection attempt"),
    (re.compile(r"<\s*(system|human|assistant)\s*>", re.I),
     "role tag injection attempt"),
    (re.compile(r"do\s+not\s+(tell|inform|mention|reveal)", re.I),
     "concealment instruction"),
    (re.compile(r"(curl|wget|fetch)\s+https?://", re.I),
     "network command in description"),
    (re.compile(r"base64\.(b64decode|decodebytes)", re.I),
     "base64 decode reference"),
    (re.compile(r"exec\s*\(|eval\s*\(", re.I),
     "code execution reference"),
    (re.compile(r"import\s+(subprocess|os|shutil|socket)", re.I),
     "dangerous import reference"),
]

def _scan_mcp_description(server_name, tool_name, description):
    findings = []
    if not description:
        return findings
    for pattern, reason in _MCP_INJECTION_PATTERNS:
        if pattern.search(description):
            findings.append(reason)
    if findings:
        logger.warning(
            "MCP server '%s' tool '%s': suspicious description content — %s",
            server_name, tool_name, "; ".join(findings),
        )
    return findings

18.2.8 工具白/黑名单

用户可以只激活 server 的部分工具:

tools/mcp_tool.py:3076-3091
tools_filter = config.get("tools") or {}
include_set = _normalize_name_filter(tools_filter.get("include"), ...)
exclude_set = _normalize_name_filter(tools_filter.get("exclude"), ...)

def _should_register(tool_name):
    if include_set:
        return tool_name in include_set    # 白名单优先
    if exclude_set:
        return tool_name not in exclude_set
    return True                              # 默认全注册

规则:

• 有 include → 只这些
• 无 include 有 exclude → 除这些之外
• 都没 → 全注册
• 同时有 → include 优先

用户体验:装 GitHub MCP server 但只想给 LLM list_issues,不给 create_repository:

mcp_servers:
  github:
    url: "https://github.mcp.example.com/mcp"
    tools:
      include: [list_issues, get_issue, list_pulls, get_pull]

18.3用户配置 schema 全貌

~/.hermes/config.yaml
mcp_servers:
  # ── 1. stdio 子进程模式 ──────────────────────
  filesystem:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
    env: {}
    timeout: 120                 # 单次工具调用超时
    connect_timeout: 60          # 初始连接超时
    enabled: true
    tools:
      include: ["read_file", "write_file"]
      exclude: ["delete_file"]
      resources: true            # 是否暴露 resources/* 工具
      prompts: true              # 是否暴露 prompts/* 工具
    supports_parallel_tool_calls: true

  # ── 2. HTTP / Streamable HTTP 模式 ──────────
  github:
    url: "https://github.mcp.example.com/mcp"
    headers:
      Authorization: "Bearer ${MCP_GITHUB_API_KEY}"   # env var 插值
    timeout: 180
    auth: "oauth"             # OAuth 2.1 PKCE

  # ── 3. SSE 模式 ──────────────────────────
  searxng:
    url: "http://localhost:8000/sse"
    transport: "sse"
    timeout: 180
    connect_timeout: 10
    sampling:                    # server 向 host 请求 LLM 完成
      enabled: true
      model: "gemini-3-flash"  # 限定模型
      max_tokens_cap: 4096
      timeout: 30
      max_rpm: 10                # 速率限制
      max_tool_rounds: 5         # 防 sampling 无限循环
      log_level: "info"

Env vars 插值在 _interpolate_env_vars()(行 2233-2243)实现,${VAR} 运行时解析。 这样 token 不写死在 config 文件里。

18.4Hermes 作为 MCP Server:mcp_serve.py

18.4.1 入口

Server 模式由 hermes mcp serve 启动,stdio 协议:

mcp_serve.py:866-897
def run_mcp_server(verbose: bool = False):
    """Start the Hermes MCP server on stdio."""
    if not _MCP_SERVER_AVAILABLE:
        print("Error: MCP server requires the 'mcp' package.", file=sys.stderr)
        sys.exit(1)

    if verbose:
        logging.basicConfig(level=logging.DEBUG, stream=sys.stderr)
    else:
        logging.basicConfig(level=logging.WARNING, stream=sys.stderr)

    bridge = EventBridge()
    bridge.start()

    server = create_mcp_server(event_bridge=bridge)

    async def _run():
        try:
            await server.run_stdio_async()
        finally:
            bridge.stop()

    try:
        asyncio.run(_run())
    except KeyboardInterrupt:
        bridge.stop()

外部 client(Claude Desktop)的配置:

{
    "mcpServers": {
        "hermes": {
            "command": "hermes",
            "args": ["mcp", "serve"]
        }
    }
}

Claude Desktop 启动后 spawn hermes mcp serve 作为子进程,通过 stdio 通信。 从 Claude Desktop 视角:Hermes 是个普通 MCP server。

18.4.2 暴露的 10 个工具

Hermes 作为 server 暴露 10 个工具(mcp_serve.py:450-859),覆盖"读 + 写 + 监听"会话:

典型用法:Claude Desktop 用户问"今天 Telegram 上有什么消息?",Claude 调 messages_read(session_key="telegram:..") 拉数据。或者跟踪审批:Claude 看到 permissions_list_open 有待批的工具调用,主动通知用户。

18.4.3 EventBridge:后台轮询 SessionDB

问题:Hermes Gateway 进程随时在写 SessionDB(新消息、新事件)。 MCP server 进程要怎么知道有新内容? 不可能每秒 query 全表。

Hermes 的解法:用文件 mtime + cursor 的轻量轮询:

mcp_serve.py:204-443
class EventBridge:
    """Background poller — 监视 SessionDB,维护内存事件队列 + waiter。

    OpenClaw 的等价是 WebSocket gateway bridge,通过事件推。
    Hermes 用 SQLite,改用轮询。
    """
    def __init__(self):
        self._queue: List[QueueEvent] = []
        self._cursor = 0
        self._lock = threading.Lock()
        self._new_event = threading.Event()
        self._running = False
        self._thread: Optional[threading.Thread] = None
        self._last_poll_timestamps: Dict[str, float] = {}
        self._pending_approvals: Dict[str, dict] = {}
        self._sessions_json_mtime: float = 0.0      # 关键 — 用 mtime 判变
        self._state_db_mtime: float = 0.0
        self._cached_sessions_index: dict = {}

核心是 mtime 短路(行 346-443):

def _poll_loop(self):
    while self._running:
        # 看 sessions.json mtime — 没动就 skip query
        cur_mtime = os.path.getmtime(SESSIONS_JSON_PATH)
        if cur_mtime == self._sessions_json_mtime:
            time.sleep(_POLL_INTERVAL)    # 200ms
            continue

        self._sessions_json_mtime = cur_mtime
        # mtime 变了 — 真去 query 拉新消息
        new_messages = _query_messages_since(self._last_poll_timestamps)
        for msg in new_messages:
            self._queue.append(QueueEvent("message", msg, ...))
        self._new_event.set()    # 唤醒 wait_for_event 的等待者

性能数学:

• 无更新时:每 200ms 一次 os.path.getmtime() = ~1 微秒。基本免费。
• 有更新:才真读 DB。
• 结果:200ms 轮询感觉实时,但 CPU 接近空闲。

18.4.4 wait_for_event:long-poll 阻塞等

外部 client 可以 "long poll"——发起请求阻塞最多 30 秒,有新事件就立刻返回。 这比 client 自己轮询省 round trip:

mcp_serve.py:268-294
def wait_for_event(self, after_cursor=0, timeout=30.0, kind_filter=None):
    """Block until matching event or timeout."""
    deadline = time.monotonic() + timeout
    while True:
        # 检查现有队列有没有匹配
        with self._lock:
            for evt in self._queue:
                if evt.cursor > after_cursor:
                    if kind_filter is None or evt.kind in kind_filter:
                        return evt
        # 队列里没,等新事件信号
        remaining = deadline - time.monotonic()
        if remaining <= 0:
            return None
        self._new_event.wait(timeout=remaining)
        self._new_event.clear()

threading.Event 是有效的 long-poll 实现——没事件时线程睡,有事件 set() 立刻唤醒。 不烧 CPU。

18.5CLI:hermes mcp 子命令

所有 MCP 操作通过 hermes mcp <verb> 暴露:

hermes_cli/mcp_config.py:743-780
def mcp_command(args):
    action = getattr(args, "mcp_action", None)
    if action == "serve":
        from mcp_serve import run_mcp_server
        run_mcp_server(verbose=getattr(args, "verbose", False))
        return

    handlers = {
        "add": cmd_mcp_add,
        "remove": cmd_mcp_remove,
        "list": cmd_mcp_list,
        "test": cmd_mcp_test,
        "configure": cmd_mcp_configure,
        "login": cmd_mcp_login,
    }
    handler = handlers.get(action)
    if handler:
        handler(args)
    else:
        cmd_mcp_list()    # 默认列出

18.5.1 hermes mcp add:Discovery-First 流程

添加 MCP server 时,Hermes 先连试 list_tools 才存配置:

hermes_cli/mcp_config.py:226-418 (摘要)
def cmd_mcp_add(args):
    name = args.name
    # ... 解析 transport 配置 ...

    # Discovery:试连
    print(f"  Connecting to '{name}'...")
    try:
        tools = _probe_single_server(name, server_config)
    except Exception as exc:
        _error(f"Failed to connect: {exc}")
        if _confirm("Save anyway (you can test later)?", default=False):
            server_config["enabled"] = False     # 默认 disabled
            _save_mcp_server(name, server_config)
            _success(f"Saved '{name}' to config (disabled)")
        return

    # 让用户选哪些工具
    _success(f"Connected! Found {len(tools)} tool(s):")
    # ... interactive checklist 选 include/exclude ...

    server_config["enabled"] = True
    _save_mcp_server(name, server_config)

关键:"connection 失败的 server 保存为 disabled"。避免每次启动 Hermes 都看到一片红色错误。 用户 fix 后跑 hermes mcp test <name> 验证再启用。

18.5.2 _probe_single_server:临时连接

hermes_cli/mcp_config.py:167-205
def _probe_single_server(name, config, connect_timeout=30):
    """临时连接,list 工具,断开。"""
    from tools.mcp_tool import (
        _ensure_mcp_loop, _run_on_mcp_loop, _connect_server, _stop_mcp_loop,
    )
    _ensure_mcp_loop()
    tools_found: List[Tuple[str, str]] = []

    async def _probe():
        server = await asyncio.wait_for(
            _connect_server(name, config), timeout=connect_timeout)
        for t in server._tools:
            desc = getattr(t, "description", "") or ""
            if len(desc) > 80:
                desc = desc[:77] + "..."
            tools_found.append((t.name, desc))
        await server.shutdown()

    try:
        _run_on_mcp_loop(_probe(), timeout=connect_timeout + 10)
    finally:
        _stop_mcp_loop()

    return tools_found

用专门的临时 event loop跑探测,完事 stop。和主 Hermes loop 隔离。

18.62025 年 Code Execution with MCP——Hermes 还没用

Anthropic 2025 推 Code Execution with MCP:让 Agent 写代码,通过 MCP server 在沙箱里执行。 比每次 inline 在 prompt 里讨论代码更安全。

Hermes 目前的 MCP 实现支持 sampling(server 反向请求 host 跑 LLM), 但没专用 code execution server 整合。这是 future direction:

• 装一个 code-exec MCP server(Node/Python 运行时)
• 给它配置:tools.include: [run_code]
• LLM 调 mcp_codeexec_run_code(code="...") 在 server sandbox 执行
• 结果回 LLM

这比 Hermes 现有的 execute_code(host 上 sandbox)更隔离—— 代码完全在 MCP server 进程,失败也不影响 host。

18.7双向架构总图

flowchart TB
  subgraph Hermes["Hermes 进程"]
    direction TB
    Agent["AIAgent"]
    Host["MCP Host
(tools/mcp_tool.py)"]
    Server["MCP Server
(mcp_serve.py)"]
    DB[(SessionDB)]
    Reg["Tool Registry"]

    Agent -->|"调 mcp_github_*"| Reg
    Reg --> Host
    Host -.-> |"_build_safe_env
凭证脱敏
circuit breaker
注入扫描"| Filters[/" 4 道防御"/]
  end

  Filters -.spawn 子进程.-> Ext1["GitHub MCP"]
  Filters -.HTTP/SSE.-> Ext2["Slack MCP"]
  Filters -.stdio.-> Ext3["Filesystem MCP"]

  Server -.读.-> DB
  Cli1["Claude Desktop"] -.stdio.-> Server
  Cli2["Cursor"] -.stdio.-> Server

  classDef agent fill:#ecf3eb,stroke:#2f5d3a,color:#2f5d3a
  classDef host fill:#f5ede0,stroke:#8b1538,color:#8b1538
  classDef server fill:#e8eff5,stroke:#2c5282,color:#2c5282
  classDef defense fill:#f0eaf1,stroke:#6b4488,color:#6b4488
  class Agent agent
  class Host host
  class Server server
  class Filters defense

18.8给 ch13 frontier 的补充:MCP 2026 演进

ch13 写于 2026-05,提到 MCP 2024.11 发布、生态有数千 server。补充三点 2026 演进:

1. OAuth 2.1 PKCE 标准化。早期 MCP server 用 Bearer token 简单认证。 2026 起官方 SDK 都支持 OAuth 2.1 PKCE,Hermes 通过 auth: "oauth" 配置启用。
2. Server-initiated sampling。MCP server 可以反向请求 host 跑 LLM 完成。 Hermes 在 sampling.max_tool_rounds: 5 防"sampling 循环" (server 调 host 调 server 调 host...)。
3. Notifications/tools/list_changed。早期 MCP 工具列表是静态的。 2026 起规范支持动态变更,Hermes 用 register(override=True) 接住。

18.9本章带走的

• Hermes 的 MCP 是双向:作为 host 消费(mcp_tool.py)+ 作为 server 暴露(mcp_serve.py)。
• Host 支持 3 种 transport:stdio / HTTP / SSE。每种 try-import 单独 fail。
• 子进程环境变量过滤(_SAFE_ENV_KEYS = {PATH, HOME, USER, ...} + XDG_* + 用户显式配置) 是 host 安全的核心一招——父进程的 OPENAI_API_KEY 永远不进 MCP server 子进程。
• 工具命名空间 mcp_<server>_<tool> 防冲突。Server 名 + 工具名都 sanitize。
• Circuit breaker(3 次失败 → 60 秒短路)防 LLM retry 风暴。 错误消息明告"~Xs 后可重试",让 LLM 自己规划。
• 凭证脱敏用 8 类正则:ghp_、sk-、Bearer、token=、key=、API_KEY=、password=、secret=。 错误消息回 LLM 前都过 _sanitize_error()。
• 工具描述注入扫描:10 类 pattern(ignore previous instructions、you are now a、 role tag injection、curl http、base64 decode、exec/eval、dangerous import)。 只警告不阻塞——保留可审计性,避免 false positive。
• Server 端通过 EventBridge 后台轮询 SessionDB。用 mtime 短路: 200ms 一次 os.path.getmtime() = ~1 微秒,文件没变就 skip query。
• wait_for_event 30 秒 long-poll 用 threading.Event。无事件时线程睡,有事件 set() 唤醒。
• Hermes 暴露 10 个工具:conversations_list / messages_read / events_poll / events_wait / messages_send / permissions_respond... 让外部 client 完整读 + 写 + 监听 Hermes 会话。
• hermes mcp add 是discovery-first:连不上就保存为 disabled,不挂启动。
• Future:Code Execution with MCP——Hermes 还没整合,但架构已 ready。