@bsbofmusic/agent-reach-mcp 0.1.1 → 0.2.0

package/README.md

@@ -1,252 +1,368 @@
-Agent-Reach MCP (stdio)
+````md
+# Agent-Reach MCP (stdio) — Full Mirror Edition
 
-A production-ready MCP (Model Context Protocol) stdio server for OpenCode / CC-Switch.
+这是一个给 **OpenCode / CC-Switch** 用的 MCP（Model Context Protocol）stdio 服务器。目标很明确：
 
-This package automatically installs and upgrades Agent-Reach on every tool call, ensuring you always run the latest version from GitHub main.
+> ✅ 导入 MCP 后，就能 **完整复刻 Agent-Reach 的全部能力**（通过 `reach_exec` 透传任意子命令）  
+> ✅ 并且满足你要求的：**简单 / 快捷 / 强大 / 永远最新**（每次调用前自动更新 Agent-Reach）
 
-Designed for:
+---
 
-✅ One-click activation via npx
+## 你将得到什么
 
-✅ Always-latest behavior
+启用这个 MCP 后，OpenCode 会多出一组工具（tools）：
 
-✅ Self-healing Python environment
+- `reach_ensure`：自愈环境 + 更新到最新 Agent-Reach
+- `reach_doctor`：执行 `agent-reach doctor`
+- `reach_read`：执行 `agent-reach read <url>`
+- ✅ `reach_exec`：执行 **任意** `agent-reach <subcommand> ...args`（全功能复刻关键）
+- `reach_list_commands`：执行 `agent-reach --help` 并解析出可用子命令列表（帮助模型“知道自己能干什么”）
 
-✅ Reusable across machines
+你不需要让 OpenCode 记住安装过程；它每次调用都会先把 Agent-Reach 升级到最新再执行。
 
-✅ Zero manual dependency management
+---
 
-✅ Works with OpenCode + CC-Switch
+## 核心理念：MCP = “能力注入”，不是“记忆依赖”
 
-🚀 What This Package Does
+OpenCode 重启会“失忆”，但 MCP 是持久配置。
 
-When enabled as an MCP server:
+- CC-Switch 负责：开关 / 配置 / 切换
+- MCP server 负责：环境自愈 + 能力暴露
+- Agent-Reach 负责：实际的多平台读/搜/配置能力
 
-Creates a dedicated Python virtual environment under your user cache directory
+所以正确心智模型是：
 
-Automatically upgrades Agent-Reach from:
+> OpenCode 不需要记住怎么安装  
+> 它只要知道：有一个 MCP tool 叫 `reach_exec`，能运行 Agent-Reach 的任何命令
 
-https://github.com/Panniantong/agent-reach/archive/main.zip
+---
 
-Executes Agent-Reach CLI commands
+## 工作原理（非常重要）
 
-Returns structured output to the LLM via MCP
+每次你调用任意一个 tool（包括 `reach_exec`），MCP 都会：
 
-This guarantees:
+1) 在用户缓存目录创建/复用 Python venv  
+2) 执行（永远最新策略）：
+   - `pip install -U https://github.com/Panniantong/agent-reach/archive/main.zip`  
+3) 然后运行对应的 `agent-reach ...` 命令  
+4) 把 stdout/stderr 回传给 OpenCode
 
-🔁 Always running latest Agent-Reach
+### venv 位置（默认）
+- Windows：`%LOCALAPPDATA%\agent-reach-mcp\runtime\venv`
+- macOS：`~/Library/Caches/agent-reach-mcp/runtime/venv`
+- Linux：`~/.cache/agent-reach-mcp/runtime/venv`
 
-🔧 No manual pip management
+---
 
-♻️ Environment automatically recreated if broken
+## 环境要求
 
-💡 Fully stateless from OpenCode’s perspective
+- Node.js >= 18
+- Python 3（系统 PATH 里能找到 `python`，Windows 也可用 `py`）
+- 能访问 GitHub（用于拉 main.zip）
 
-🧠 Architecture Overview
-OpenCode
-   ↓
-MCP (stdio)
-   ↓
-Node.js server (this package)
-   ↓
-Auto-managed Python venv (user cache)
-   ↓
-Latest Agent-Reach (pip install -U main.zip)
+> 说明：某些平台能力（例如需要 cookie / 代理 / docker 的）属于 Agent-Reach 上游能力，你需要按 doctor 输出提示去配。
 
-The Python environment is stored in:
+---
 
-Windows:
+## 安装与本地验证（开发者）
 
-%LOCALAPPDATA%\agent-reach-mcp\runtime\venv
+在项目目录：
 
-macOS:
-
-~/Library/Caches/agent-reach-mcp/runtime/venv
-
-Linux:
-
-~/.cache/agent-reach-mcp/runtime/venv
-📦 Installation (Local Development)
+```bash
 npm install
 node index.js
+````
 
-If the process starts without crashing, it is working correctly (stdio server waits for input).
+stdio MCP server 启动后会等待输入，这属于正常现象。
 
-📤 Publish to npm
+---
 
-1️⃣ Edit package.json name:
+## 发布到 npm（手动，无 CI）
 
-"name": "@your-scope/agent-reach-mcp"
+### 1) 修改 package.json
 
-or without scope:
+确保：
 
-"name": "agent-reach-mcp-yourname"
+* `name` 是你自己的包名（建议 scope 包：`@你的scope/agent-reach-mcp`）
+* `version` 每次发布都 +1（npm 禁止同版本覆盖）
 
-2️⃣ Publish:
+### 2) 发布
 
+```bash
 npm login
 npm publish --access public
-⚙️ Using With CC-Switch
+```
+
+---
+
+## CC-Switch / OpenCode 配置方式（你要的“一键复活”）
 
-Add this configuration:
+在 CC-Switch 新建 MCP 配置：
 
+```json
 {
   "command": "npx",
   "args": ["-y", "@your-scope/agent-reach-mcp@latest"],
   "type": "stdio"
 }
+```
+
+然后重启 OpenCode。
+
+> 之后只要你更新 npm 包版本，用户侧 `@latest` 会在下次启动时拉到新版本（通常如此；依赖 npx 缓存策略）。
+
+---
+
+# Tools 使用说明（强烈建议认真看）
+
+## 0) 第一次使用推荐流程
 
-Then:
+1. `reach_ensure`（确保环境就绪）
+2. `reach_doctor`（看哪些渠道通、怎么配）
+3. `reach_list_commands`（让 OpenCode 知道有哪些子命令）
+4. 用 `reach_exec` 跑你要的平台命令
 
-Enable MCP
+---
 
-Restart OpenCode
+## 1) reach_ensure
 
-Tools will be automatically available
+用途：只做环境准备 + 更新。
 
-🛠 Available MCP Tools
-1️⃣ reach_ensure
+它等价于：
 
-Ensures:
+* 创建 venv
+* pip 工具链更新
+* pip 安装/升级 Agent-Reach main.zip
 
-Python venv exists
+适用场景：
 
-Agent-Reach upgraded to latest
+* 第一次启用 MCP
+* 你怀疑环境坏了
+* 你想强制刷新到最新
 
-Returns installation logs.
+---
 
-2️⃣ reach_doctor
+## 2) reach_doctor
 
-Runs:
+用途：诊断所有渠道状态。
 
+它会执行：
+
+```bash
 agent-reach doctor
+```
+
+适用场景：
+
+* 为什么某个平台读不到？
+* 需要 cookie 吗？
+* 需要代理吗？
+* 需要 docker 吗？
+
+doctor 是 Agent-Reach 官方推荐的“总检命令”。
+
+---
 
-Automatically upgrades before execution.
+## 3) reach_read
 
-3️⃣ reach_read
+用途：读一个链接（网页/视频/仓库等，交给 Agent-Reach 判断）。
 
-Runs:
+它会执行：
 
+```bash
 agent-reach read <url>
+```
 
-Automatically upgrades before execution.
+输入：
 
-Example input:
+```json
+{ "url": "https://example.com" }
+```
 
-{
-  "url": "https://example.com"
-}
-🔄 Always Latest Behavior
+### 常见例子
+
+* 读普通网页：
+
+```json
+{ "url": "https://example.com" }
+```
+
+* 获取 YouTube 教程字幕/内容（Agent-Reach README 的示例就是 read YouTube）：
 
-This package intentionally prioritizes:
+```json
+{ "url": "https://youtube.com/watch?v=xxx" }
+```
 
-Latest > Stability
+---
 
-On every tool call:
+## 4) reach_exec ✅（全功能复刻关键）
 
-pip install -U https://github.com/Panniantong/agent-reach/archive/main.zip
+这是“完整复刻”的核心。它可以透传执行任何 Agent-Reach 子命令：
 
-This ensures:
+等价于：
 
-New features immediately available
+```bash
+agent-reach <subcommand> ...args
+```
 
-Bug fixes applied instantly
+输入格式：
 
-No stale installs
+```json
+{
+  "subcommand": "doctor",
+  "args": [],
+  "timeoutMs": 600000
+}
+```
+
+### 4.1 安装（对应 Agent-Reach README 的安装方式）
+
+> 虽然 MCP 自己会安装 main.zip，但 Agent-Reach 还有 “install” 用来装系统依赖/配置渠道（很重要）
+
+* 全自动安装（默认推荐）：
 
-⚠️ If upstream breaks, you get upstream behavior immediately (by design).
+```json
+{ "subcommand": "install", "args": ["--env=auto"] }
+```
 
-🛡 Stability Notes
+* 安全模式（不自动改系统，只提示缺什么）：
 
-This MCP server:
+```json
+{ "subcommand": "install", "args": ["--env=auto", "--safe"] }
+```
 
-Automatically recreates venv if deleted
+* Dry Run（预览将做什么，不执行）：
 
-Upgrades pip tooling
+```json
+{ "subcommand": "install", "args": ["--env=auto", "--dry-run"] }
+```
+
+### 4.2 Twitter/X：配置 cookie + 搜索推文（来自官方 README FAQ）
+
+* 配置 twitter cookie（你需要把 Cookie-Editor 导出的 cookie 字符串填进去）：
+
+```json
+{
+  "subcommand": "configure",
+  "args": ["twitter-cookies", "your_cookies_here"]
+}
+```
 
-Fallbacks to python -m agent_reach if console script missing
+* 搜索推文：
 
-Captures stdout/stderr
+```json
+{
+  "subcommand": "search-twitter",
+  "args": ["关键词"]
+}
+```
 
-Handles timeouts
+### 4.3 代理配置（解决 Reddit 数据中心 IP 403 等，来自官方 README FAQ）
 
-Returns structured MCP errors
+```json
+{
+  "subcommand": "configure",
+  "args": ["proxy", "http://user:pass@ip:port"]
+}
+```
 
-🧩 Requirements
+### 4.4 小红书：搜索（来自官方 README FAQ）
 
-Node.js >= 18
+```json
+{
+  "subcommand": "search-xhs",
+  "args": ["关键词"]
+}
+```
 
-Python 3 available in PATH
+> 小红书往往需要 docker / MCP 服务配套，先跑 `reach_doctor` 看提示。
 
-pip available
+### 4.5 读任意链接（等价 reach_read，但更通用）
 
-Internet connection
+```json
+{
+  "subcommand": "read",
+  "args": ["https://github.com/Panniantong/Agent-Reach"]
+}
+```
 
-🔍 Why Use MCP Instead of Direct CLI?
+---
 
-Because:
+## 5) reach_list_commands（推荐让 OpenCode“自发现”能力）
 
-OpenCode forgets memory after restart
+用途：列出当前安装的 Agent-Reach 版本支持哪些子命令。
 
-MCP ensures environment is rebuilt automatically
+为什么需要它？
 
-Tools become persistent capabilities
+* Agent-Reach 在快速迭代
+* 你坚持“永远最新”
+* 所以命令集合可能随时变化
+* `reach_list_commands` 能让 OpenCode 在**没有记忆**的情况下，仍然准确知道有哪些子命令
 
-One-click activation via CC-Switch
+推荐用法：
 
-No manual installation per machine
+1. 启用 MCP 后先跑一次 `reach_list_commands`
+2. OpenCode 会得到一份命令列表
+3. 后续就用 `reach_exec` 调用列表里的命令
 
-🏗 Design Philosophy
+---
 
-Minimal
+# 推荐验证计划（你可以照抄给 OpenCode 执行）
 
-Stateless
+## Phase 1：基础健康
 
-Self-healing
+1. `reach_ensure`
+2. `reach_doctor`
+3. `reach_read` 读一个普通网页
 
-Always current
+预期：能成功安装/更新 + doctor 输出渠道状态 + read 有返回内容
 
-Reusable anywhere via npx
+## Phase 2：全能力复刻
 
-📄 License
+1. `reach_list_commands`
+2. 从列表里挑 3 个子命令用 `reach_exec` 跑（例如 install / configure / search-* / read）
 
-MIT
+## Phase 3：按需补齐配置
 
-💡 Example OpenCode Prompt
+* Twitter 需要 cookie：用 `configure twitter-cookies ...`
+* 服务器访问 Reddit/B站可能需要代理：用 `configure proxy ...`
+* 小红书可能需要 docker：按 doctor 指引
 
-After enabling MCP:
+---
 
-Use reach_read to analyze https://example.com
+# 常见问题（FAQ）
 
-Or:
+## Q1: 为什么我明明启用了 MCP，但某个平台用不了？
 
-Run reach_doctor and summarize health status
-🔮 Future Extensions (Optional)
+A：平台能力取决于 Agent-Reach 的“渠道状态”，不是 MCP 本身。跑 `reach_doctor` 看缺什么（cookie、代理、docker、登录等）。
 
-Possible future improvements:
+## Q2: 为什么每次调用都要更新？会不会慢？
 
-Version pin mode
+A：这是你选择的策略：Always-Latest。首次或上游更新时会慢，但能保证永远最新。如果以后你要“快且稳”，可以改成“每日一次更新/或失败回滚”。
 
-Automatic rollback on failure
+## Q3: 如何避免 OpenCode 重启后不知道有哪些命令？
 
-Dependency preflight checks
+A：用 `reach_list_commands`。这是为“无记忆模型”专门做的能力自发现入口。
 
-Docker isolation mode
+## Q4: 我想要更友好的工具（比如 reach_search_twitter / reach_search_xhs）要不要做？
 
-Logging level control
+A：可以做，但不是必须。`reach_exec` 已经完整复刻；单独工具只是“更强的 schema 引导”。
 
-Configurable update strategy
+---
 
-✅ Summary
+# License
 
-You now have:
+MIT
 
-A reusable MCP server
+```
 
-Publishable npm package
+---
 
-Always-latest Agent-Reach integration
+### 我对齐了哪些“真实命令名”（可核对）
+这些命令名来自 Agent-Reach 最新 README 中的安装方式与 FAQ：`configure twitter-cookies`、`search-twitter`、`configure proxy`、`search-xhs`、`read`、`doctor`、`install --env=auto/--safe/--dry-run`。 :contentReference[oaicite:1]{index=1}
 
-Zero manual maintenance workflow
+如果你愿意，我还可以再给你一个**更强的 README 增强版**：把 `reach_list_commands` 的输出示例也写进去，并给一份“OpenCode Prompt 模板”（让模型自动：list_commands → 选命令 → exec）。
+::contentReference[oaicite:2]{index=2}
+```
 
-One-click OpenCode integration
+[1]: https://github.com/Panniantong/Agent-Reach "GitHub - Panniantong/Agent-Reach: Give your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees."

package/index.js

@@ -12,12 +12,16 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 
 /**
- * A minimal, robust MCP stdio server that:
- * - Creates a Python venv under user cache dir
- * - On EVERY tool call, upgrades Agent-Reach from GitHub main.zip
- * - Executes `agent-reach` via the venv (fallback to python -m ...)
+ * Agent-Reach MCP (stdio) — Full capability proxy
  *
- * NOTE: This favors "latest" over strict stability, per your requirement.
+ * Goals:
+ * - Import MCP => "full Agent-Reach" via reach_exec (generic passthrough)
+ * - Still provide ergonomic basics: ensure / doctor / read
+ * - On EVERY tool call: auto-upgrade Agent-Reach from GitHub main.zip (always latest)
+ *
+ * Notes:
+ * - This favors "latest" over strict stability, per your requirement.
+ * - It manages its own python venv in user cache.
  */
 
 function isWindows() {
@@ -101,8 +105,6 @@ async function createVenvIfMissing(root) {
 
   if (existsSync(pythonExe)) return;
 
-  // Try creating venv using system python.
-  // Windows: python, then py -3
   const candidates = isWindows()
     ? [
         { cmd: "python", args: ["-m", "venv", venvDir] },
@@ -120,7 +122,9 @@ async function createVenvIfMissing(root) {
   }
 
   if (!existsSync(pythonExe)) {
-    const tried = candidates.map((c) => `${c.cmd} ${c.args.join(" ")}`).join(" | ");
+    const tried = candidates
+      .map((c) => `${c.cmd} ${c.args.join(" ")}`)
+      .join(" | ");
     const err = last?.stderr || "";
     throw new Error(
       `Failed to create Python venv.\nTried: ${tried}\nLast stderr:\n${err}`
@@ -133,15 +137,19 @@ async function ensureLatestAgentReach(root) {
   const { pythonExe, agentReachExe } = venvPaths(root);
 
   // Upgrade pip tooling (best effort)
-  await run(pythonExe, ["-m", "pip", "install", "-U", "pip", "setuptools", "wheel"], {
-    timeoutMs: 5 * 60 * 1000,
-  });
+  await run(
+    pythonExe,
+    ["-m", "pip", "install", "-U", "pip", "setuptools", "wheel"],
+    { timeoutMs: 5 * 60 * 1000 }
+  );
 
-  // Your "always latest" requirement:
+  // ALWAYS LATEST (main branch zip)
   const pkgUrl = "https://github.com/Panniantong/agent-reach/archive/main.zip";
-  const installRes = await run(pythonExe, ["-m", "pip", "install", "-U", pkgUrl], {
-    timeoutMs: 10 * 60 * 1000,
-  });
+  const installRes = await run(
+    pythonExe,
+    ["-m", "pip", "install", "-U", pkgUrl],
+    { timeoutMs: 10 * 60 * 1000 }
+  );
 
   let log = `pip install -U ${pkgUrl}\nexit=${installRes.code}\n`;
   if (installRes.stdout.trim()) log += `stdout:\n${installRes.stdout}\n`;
@@ -158,17 +166,19 @@ async function ensureLatestAgentReach(root) {
   return { pythonExe, agentReachExe, ensureLog: log };
 }
 
-async function runAgentReach(root, args) {
-  const { pythonExe, agentReachExe, ensureLog } = await ensureLatestAgentReach(root);
+async function runAgentReach(root, args, extraOpts = {}) {
+  const { pythonExe, agentReachExe, ensureLog } = await ensureLatestAgentReach(
+    root
+  );
+
+  const timeoutMs = extraOpts.timeoutMs ?? 10 * 60 * 1000;
 
   let execRes;
   if (existsSync(agentReachExe)) {
-    execRes = await run(agentReachExe, args, { timeoutMs: 10 * 60 * 1000 });
+    execRes = await run(agentReachExe, args, { timeoutMs });
   } else {
-    // Fallback: module import. (May vary; best effort.)
-    execRes = await run(pythonExe, ["-m", "agent_reach", ...args], {
-      timeoutMs: 10 * 60 * 1000,
-    });
+    // Fallback: module import (best effort)
+    execRes = await run(pythonExe, ["-m", "agent_reach", ...args], { timeoutMs });
   }
 
   let out = `# ensure_latest\n${ensureLog}\n`;
@@ -179,13 +189,55 @@ async function runAgentReach(root, args) {
   return { out, code: execRes.code };
 }
 
+/**
+ * Best-effort command listing:
+ * - Try: `agent-reach --help`
+ * - Parse lines that look like subcommands.
+ */
+function parseCommandsFromHelp(helpText) {
+  const lines = helpText.split(/\r?\n/);
+  const commands = new Set();
+
+  // Common patterns:
+  //   "Commands:" section in Click/Typer
+  //   indented: "read      ..." or "doctor    ..."
+  let inCommands = false;
+  for (const raw of lines) {
+    const line = raw.trimEnd();
+
+    if (/^Commands:\s*$/i.test(line.trim())) {
+      inCommands = true;
+      continue;
+    }
+    if (inCommands && line.trim() === "") {
+      // stop after an empty line (often ends section)
+      // (but some help formats include blank lines; be conservative)
+      // We'll not hard-stop here.
+    }
+
+    if (inCommands) {
+      const m = line.match(/^\s{0,4}([a-zA-Z0-9][a-zA-Z0-9_-]+)\s{2,}.*$/);
+      if (m?.[1]) commands.add(m[1]);
+    } else {
+      // Some CLIs list commands without explicit "Commands:" header
+      const m = line.match(/^\s{0,4}([a-zA-Z0-9][a-zA-Z0-9_-]+)\s{2,}.*$/);
+      if (m?.[1] && !/^(Usage|Options|Arguments):?$/i.test(m[1])) {
+        // Only add if it doesn't look like a header.
+        // But to avoid noise, we won't add outside commands section.
+      }
+    }
+  }
+
+  return Array.from(commands).sort();
+}
+
 function text(content) {
   return [{ type: "text", text: content }];
 }
 
 async function main() {
   const server = new Server(
-    { name: "agent-reach-mcp", version: "0.1.0" },
+    { name: "agent-reach-mcp", version: "0.2.0" },
     { capabilities: { tools: {} } }
   );
 
@@ -218,6 +270,38 @@ async function main() {
             required: ["url"],
           },
         },
+        {
+          name: "reach_exec",
+          description:
+            "Execute ANY Agent-Reach subcommand. Example: {subcommand:'search-xhs', args:['关键词']} or {subcommand:'read', args:['https://...']}. Auto-updates Agent-Reach first.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              subcommand: {
+                type: "string",
+                description:
+                  "Agent-Reach subcommand name, e.g. 'search-xhs', 'read', 'doctor', etc.",
+              },
+              args: {
+                type: "array",
+                items: { type: "string" },
+                description: "Arguments passed to the subcommand",
+              },
+              timeoutMs: {
+                type: "number",
+                description:
+                  "Optional timeout in milliseconds for the command execution (default ~10 minutes).",
+              },
+            },
+            required: ["subcommand"],
+          },
+        },
+        {
+          name: "reach_list_commands",
+          description:
+            "List available Agent-Reach subcommands by parsing `agent-reach --help`. Auto-updates Agent-Reach first.",
+          inputSchema: { type: "object", properties: {} },
+        },
       ],
     };
   });
@@ -240,12 +324,68 @@ async function main() {
       if (name === "reach_read") {
         const url = String(input.url ?? "");
         if (!url || !/^https?:\/\//i.test(url)) {
-          return { content: text("Invalid url. Must start with http(s)://"), isError: true };
+          return {
+            content: text("Invalid url. Must start with http(s)://"),
+            isError: true,
+          };
         }
-        const { out, code } = await runAgentReach(runtimeRoot, ["read", url]);
+        const { out, code } = await runAgentReach(runtimeRoot, ["read", url], {
+          timeoutMs: 10 * 60 * 1000,
+        });
         return { content: text(out), isError: code !== 0 };
       }
 
+      if (name === "reach_exec") {
+        const subcommand = String(input.subcommand ?? "").trim();
+        const args = Array.isArray(input.args) ? input.args.map(String) : [];
+        const timeoutMs =
+          typeof input.timeoutMs === "number" && input.timeoutMs > 0
+            ? Math.floor(input.timeoutMs)
+            : 10 * 60 * 1000;
+
+        if (!subcommand) {
+          return {
+            content: text("Missing required field: subcommand"),
+            isError: true,
+          };
+        }
+
+        // Minimal safety: prevent command injection by disallowing whitespace in subcommand
+        // (args are passed as array so they are safe).
+        if (/\s/.test(subcommand)) {
+          return {
+            content: text("Invalid subcommand (contains whitespace)."),
+            isError: true,
+          };
+        }
+
+        const { out, code } = await runAgentReach(
+          runtimeRoot,
+          [subcommand, ...args],
+          { timeoutMs }
+        );
+        return { content: text(out), isError: code !== 0 };
+      }
+
+      if (name === "reach_list_commands") {
+        const { out, code } = await runAgentReach(runtimeRoot, ["--help"], {
+          timeoutMs: 2 * 60 * 1000,
+        });
+
+        // Parse only from stdout/stderr combined output we already include.
+        const helpText = out;
+        const commands = parseCommandsFromHelp(helpText);
+
+        const payload = [
+          "# parsed_commands",
+          commands.length ? commands.join("\n") : "(no commands parsed; see help output below)",
+          "",
+          out,
+        ].join("\n");
+
+        return { content: text(payload), isError: code !== 0 };
+      }
+
       return { content: text(`Unknown tool: ${name}`), isError: true };
     } catch (e) {
       const msg = e?.stack || e?.message || String(e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsbofmusic/agent-reach-mcp",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "MCP stdio server that auto-installs/updates Agent-Reach and exposes reach_* tools.",
   "license": "MIT",
   "type": "module",