dsh-baton-mcp 0.4.0 → 0.5.1

package/README.md

@@ -3,7 +3,7 @@
 </p>
 
 <p align="center">
-  English | <a href="README.zh-CN.md">中文</a> · Unofficial; not affiliated with DeepSeek.
+  English | <a href="README.zh-CN.md">中文</a>
 </p>
 
 <p align="center">
@@ -37,64 +37,18 @@ Codex and Claude take turns in the same Harness session, and every message is la
 ## Quick start
 
 <p align="center">
-  <img src="./assets/readme/install.svg" width="100%" alt="Step 1: run npx -y dsh-baton-mcp setup. Step 2: in Harness open Plugins, Add plugin, enter dsh-baton-host from the npm registry, Install, Enable now. Step 3: in a new chat, ask for dsh_list_workspaces">
+  <img src="./assets/readme/install.svg" width="100%" alt="Step 1: in Harness open Plugins, Add plugin, enter dsh-baton-host, Install, Enable now; it registers dsh-baton for Claude Code and Codex. Step 2: in a new chat, ask for dsh_list_workspaces">
 </p>
 
-Requires DeepSeek Harness ≥ 0.2.1-rc.2 (signed in), Node.js ≥ 22.15. On Windows, see [WINDOWS.md](WINDOWS.md).
+Requires DeepSeek Harness ≥ 0.2.1-rc.2 (signed in), Node.js ≥ 22.15, and Claude Code or Codex. The steps are the same on macOS and Windows.
 
-**1. Run setup** in a terminal:
+**1. Add the plugin in Harness:** **Plugins** (插件) → **Add plugin** (添加插件) → type `dsh-baton-host` → **Install** (安装) → **Enable now** (立即启用).
 
-```bash
-npx -y dsh-baton-mcp setup
-```
-
-dsh-baton has no dependencies. `setup` copies itself to `~/.dsh-baton/app`, a folder that stays put (npx's cache does not), and registers the MCP server once, user-wide, for Claude Code and Codex: every new conversation, in any folder, has the `dsh_*` tools. It writes `~/.claude.json` and `~/.codex/config.toml` directly (a backup of each is kept as `*.bak-dsh-baton`), so it also works when only the desktop apps are installed and `claude` / `codex` are not on your `PATH`. Running it again is safe.
-
-**2. Add the plugin in Harness**, by its npm package name (`setup` copies it to your clipboard):
-
-**Plugins** (插件) → **Add plugin** (添加插件) → registry **Official npm registry** → `dsh-baton-host` → **Install** (安装) → **Enable now** (立即启用)
-
-**3. Check.** Start a **new** conversation in Claude Code or Codex and ask it to call `dsh_list_workspaces`. It lists your Harness workspaces.
-
-**Or let Claude Code or Codex do it:** paste *"Run `npx -y dsh-baton-mcp setup`, then tell me the Harness step it prints."*
-
-**How each client waits** (nothing to configure):
-- **Claude Code** waits for a run in the background (the `wait_command` that `dsh_send` returns) and is woken once, when the run ends.
-- **Codex** waits inside `dsh_wait`, up to 270 s per call, just under its 300 s tool timeout. An unfinished wait returns only the state, so Codex calls again without summarising. Codex gets no `wait_command`: its terminal cannot wake it, so it would poll.
-- Codex asks you to approve MCP tool calls: approve the `dsh-baton` tools. For unattended `codex exec` runs, add `--approve-for-me`.
-
-**Updating:** the MCP server and the plugin update separately, and both carry the same version.
-- MCP server: `npx -y dsh-baton-mcp@latest setup`. New conversations use it.
-- Plugin: Harness offers an update button only for its own official plugins, so for this one: Plugins → dsh-baton-host → **Uninstall**, then **Add plugin** → `dsh-baton-host` again.
-- `setup` says when the two are out of step, and so does the first tool call that notices it.
-
-**Removing:** Harness → Plugins → dsh-baton-host → **Uninstall**, and `npx -y dsh-baton-mcp setup --remove`. That removes the MCP entries and `~/.dsh-baton/app`; run records stay in `~/.dsh-baton` until you delete it.
-
-**Upgrading from dsh-bridge**: run `setup` as above. It replaces the old `dsh-bridge` MCP entries; in Harness, uninstall `dsh-bridge-host`, then add `dsh-baton-host` as in step 2. `DSH_BRIDGE_*` variables and an existing `~/.dsh-bridge` folder keep working for now. Tools get a new prefix (`mcp__dsh-baton__…`), so update any permission allowlists.
-
-**Installed from a local folder before 0.4?** Earlier versions had you paste `~/.dsh-baton/app/host`. That still works, but it does not update with npm: uninstall it and add `dsh-baton-host` by name. `setup` points this out.
-
-**From source** (to follow `main` or to change the code): `git clone https://github.com/JialaoLiu/dsh-baton.git` and `node dsh-baton/src/cli.mjs setup`. setup then registers the clone itself and has you add the plugin from the clone's `host` folder (Add plugin → paste the path it copies), so plugin changes run before they are published; update with `git pull`.
+Switched on, the plugin registers dsh-baton for Claude Code and Codex, for every folder, and Harness says so.
 
-<details>
-<summary>Manual registration and the Claude desktop app</summary>
-
-`setup` writes the same entries these commands would (with the absolute path of `node`, since desktop apps start MCP servers without your shell's `PATH`):
-
-```bash
-claude mcp add dsh-baton -s user -- "$(command -v node)" "$PWD/dsh-baton/src/server.mjs"
-codex mcp add dsh-baton -- "$(command -v node)" "$PWD/dsh-baton/src/server.mjs"
-```
-
-`-s user` matters: without it, Claude Code registers the server for the current project folder only.
-
-**Claude desktop app (optional)**: for the chat app's connectors (separate from Claude Code), add this to `~/Library/Application Support/Claude/claude_desktop_config.json` and restart the app. It shows as a "Local dev" connector.
-
-```json
-{ "mcpServers": { "dsh-baton": { "command": "/absolute/path/to/node", "args": ["/absolute/path/to/dsh-baton/src/server.mjs"] } } }
-```
+**2. Check:** in a **new** Claude Code or Codex conversation, ask it to call `dsh_list_workspaces`. It lists your Harness workspaces.
 
-</details>
+That is all. If Harness says it could not register (no Node.js found, say), run `npx -y dsh-baton-mcp setup` in a terminal; it does the same registration. Updating, removing and Windows details are [further down](#install-details).
 
 ## How it works
 
@@ -106,6 +60,11 @@ codex mcp add dsh-baton -- "$(command -v node)" "$PWD/dsh-baton/src/server.mjs"
   <img src="./assets/readme/comparison.svg" width="100%" alt="Plugin vs headless: only the plugin shows runs live in the Harness UI, continues desktop sessions and uses desktop agent presets; both reuse the desktop sign-in">
 </p>
 
+**How each client waits** (nothing to configure):
+- **Claude Code** waits for a run in the background (the `wait_command` that `dsh_send` returns) and is woken once, when the run ends.
+- **Codex** waits inside `dsh_wait`, up to 270 s per call, just under its 300 s tool timeout. An unfinished wait returns only the state, so Codex calls again without summarising. Codex gets no `wait_command`: its terminal cannot wake it, so it would poll.
+- Codex asks you to approve MCP tool calls: approve the `dsh-baton` tools. For unattended `codex exec` runs, add `--approve-for-me`.
+
 ## Tools
 
 <p align="center">
@@ -173,6 +132,42 @@ When the plugin is unreachable, the MCP server falls back to Harness's `dsh head
 
 </details>
 
+## Install details
+
+**What the plugin does when switched on.** It copies the MCP server to `~/.dsh-baton/app`, a folder that stays put, and writes the MCP entry into `~/.claude.json` and `~/.codex/config.toml` directly, keeping a `*.bak-dsh-baton` backup of each. It registers the `node` it finds on `PATH` (never the one inside Harness), so it works with only the desktop apps installed, when `claude` / `codex` are not on your `PATH`. It runs again on each Harness start: an entry that is already right, or a working one that starts another copy of dsh-baton, is left alone. In Harness, the source switches to the npm registry ("Official npm registry", 「npm 官方源」) by itself once you type the package name, and no restart is needed. To turn the registration off, set `DSH_BATON_AUTO_REGISTER=0` for Harness.
+
+**`npx -y dsh-baton-mcp setup`** does the same registration from a terminal: for a plugin that could not register, or when you come from an MCP directory. With the plugin already registered it changes nothing, then points you to the plugin if it is missing.
+
+**Updating.** Harness has an update button only for its official plugins, so: Plugins → dsh-baton-host → **Uninstall**, then **Add plugin** → `dsh-baton-host`. For a while after a release, Harness installs the previous version instead (pnpm's `minimumReleaseAge` holds back versions published very recently, and the install dialog says so); to get the new one at once, type the version: `dsh-baton-host@0.5.0`. Switched on again, the plugin brings the MCP server to the same version; new conversations use it. If the two are ever out of step, the first tool call that notices it says so.
+
+**Removing.** Harness → Plugins → dsh-baton-host → **Uninstall**, then `npx -y dsh-baton-mcp setup --remove`. The plugin cannot tell an uninstall from Harness quitting, so it leaves the MCP entries to that command, which also deletes `~/.dsh-baton/app`; run records stay in `~/.dsh-baton` until you delete it.
+
+**Upgrading from dsh-bridge.** In Harness, uninstall `dsh-bridge-host`, then add `dsh-baton-host`; switched on, it replaces the old `dsh-bridge` MCP entries. `DSH_BRIDGE_*` variables and an existing `~/.dsh-bridge` folder keep working for now. Tools get a new prefix (`mcp__dsh-baton__…`), so update any permission allowlists. A plugin added before 0.4 by pasting `~/.dsh-baton/app/host` still works but does not update with npm: uninstall it and add `dsh-baton-host` by name.
+
+**From source** (to follow `main` or change the code): `git clone https://github.com/JialaoLiu/dsh-baton.git`, then in Harness add the plugin from the clone's `host` folder (Add plugin → paste the path). Switched on, it registers the clone itself, so changes run before they are published. Update with `git pull`. `node dsh-baton/src/cli.mjs setup` registers the clone from a terminal.
+
+**Windows.** Same steps; [WINDOWS.md](WINDOWS.md) covers what differs (a named pipe instead of a socket file) and fixes for a Plugins page that cannot install or uninstall.
+
+<details>
+<summary>Manual registration and the Claude desktop app</summary>
+
+The plugin and `setup` write the same entries these commands would (with the absolute path of `node`, since desktop apps start MCP servers without your shell's `PATH`):
+
+```bash
+claude mcp add dsh-baton -s user -- "$(command -v node)" "$PWD/dsh-baton/src/server.mjs"
+codex mcp add dsh-baton -- "$(command -v node)" "$PWD/dsh-baton/src/server.mjs"
+```
+
+`-s user` matters: without it, Claude Code registers the server for the current project folder only.
+
+**Claude desktop app (optional)**: for the chat app's connectors (separate from Claude Code), add this to `~/Library/Application Support/Claude/claude_desktop_config.json` and restart the app. It shows as a "Local dev" connector.
+
+```json
+{ "mcpServers": { "dsh-baton": { "command": "/absolute/path/to/node", "args": ["/absolute/path/to/dsh-baton/src/server.mjs"] } } }
+```
+
+</details>
+
 ## Security and limits
 
 <p align="center">

package/README.zh-CN.md

@@ -3,7 +3,7 @@
 </p>
 
 <p align="center">
-  <a href="README.md">English</a> | 中文 · 非官方项目，与 DeepSeek 无关。
+  <a href="README.md">English</a> | 中文
 </p>
 
 <p align="center">
@@ -37,64 +37,18 @@ Codex 和 Claude 轮流往同一个 Harness 对话发消息，每条都标明是
 ## 快速上手
 
 <p align="center">
-  <img src="./assets/readme/zh/install.svg" width="100%" alt="第一步：运行 npx -y dsh-baton-mcp setup。第二步：Harness → 插件 → 添加插件 → 从 npm 输入 dsh-baton-host → 安装 → 立即启用。第三步：新开对话，让它调用 dsh_list_workspaces">
+  <img src="./assets/readme/zh/install.svg" width="100%" alt="第一步：Harness → 插件 → 添加插件 → 输入 dsh-baton-host → 安装 → 立即启用，它会为 Claude Code 和 Codex 注册 dsh-baton。第二步：新开对话，让它调用 dsh_list_workspaces">
 </p>
 
-需要：DeepSeek Harness ≥ 0.2.1-rc.2 并已登录；Node.js ≥ 22.15。Windows 见 [WINDOWS.md](WINDOWS.md)。
+需要：DeepSeek Harness ≥ 0.2.1-rc.2 并已登录；Node.js ≥ 22.15；装了 Claude Code 或 Codex。macOS 和 Windows 步骤完全相同。
 
-**1. 运行 setup**，在终端里：
+**1. 在 Harness 里添加插件：** 插件 → 添加插件 → 输入 `dsh-baton-host` → 安装 → 立即启用。
 
-```bash
-npx -y dsh-baton-mcp setup
-```
-
-dsh-baton 没有任何依赖。`setup` 会把自己复制到 `~/.dsh-baton/app` 这个固定的文件夹（npx 的缓存目录会变），然后在用户级别给 Claude Code 和 Codex 注册一次 MCP 服务器：之后在任何文件夹新开的对话都有 `dsh_*` 工具。它直接写 `~/.claude.json` 和 `~/.codex/config.toml`（各留一份 `*.bak-dsh-baton` 备份），所以只装了桌面应用、`claude` / `codex` 不在 `PATH` 里也能用。重复运行也没问题。
-
-**2. 在 Harness 里按包名添加插件**（`setup` 已经把包名复制到剪贴板）：
-
-**插件** → **添加插件** → 来源选 **Official npm registry** → 输入 `dsh-baton-host` → **安装** → **立即启用**
-
-**3. 检查。**在 Claude Code 或 Codex 里**新开**一个对话，让它调用 `dsh_list_workspaces`，应该会列出你的 Harness 工作区。
-
-**也可以让 Claude Code 或 Codex 帮你装：** 发给它 *"运行 `npx -y dsh-baton-mcp setup`，然后告诉我它提示的 Harness 那一步。"*
-
-**各客户端怎么等待**（不需要配置）：
-- **Claude Code** 在后台等待任务（`dsh_send` 返回的 `wait_command`），任务结束时只被唤醒一次。
-- **Codex** 在 `dsh_wait` 里等待，每次最多 270 秒，刚好低于它 300 秒的工具超时。没做完时只返回状态，Codex 会直接再调用，不会去总结进度。Codex 不会收到 `wait_command`：它的终端无法在命令结束时唤醒它，只能轮询。
-- Codex 调用 MCP 工具时会请你批准，批准 `dsh-baton` 的工具即可；无人值守的 `codex exec` 加上 `--approve-for-me`。
-
-**更新：** MCP 服务器和插件分开更新，两者版本号相同。
-- MCP 服务器：`npx -y dsh-baton-mcp@latest setup`，新开的对话就会用上。
-- 插件：Harness 只给官方插件提供"更新"按钮，所以这个插件要：插件 → dsh-baton-host → **卸载**，再**添加插件** → `dsh-baton-host`。
-- 两边版本对不上时，`setup` 会提示，第一次发现不一致的工具调用也会提示。
-
-**卸载：** Harness → 插件 → dsh-baton-host → **卸载**，再运行 `npx -y dsh-baton-mcp setup --remove`。它会删掉 MCP 注册和 `~/.dsh-baton/app`；运行记录留在 `~/.dsh-baton`，不需要的话自己删掉。
-
-**从 dsh-bridge 升级：**照上面运行 `setup`。它会替换掉旧的 `dsh-bridge` MCP 注册；在 Harness 里先卸载 `dsh-bridge-host`，再按第 2 步添加 `dsh-baton-host`。`DSH_BRIDGE_*` 环境变量和已有的 `~/.dsh-bridge` 文件夹暂时继续可用。工具前缀变成 `mcp__dsh-baton__…`，权限白名单里写了旧前缀的要改一下。
-
-**0.4 之前从本地文件夹装的插件：**旧版本让你粘贴 `~/.dsh-baton/app/host`。这样装的仍然能用，但不会跟着 npm 更新：卸载它，再按包名添加 `dsh-baton-host`。`setup` 会提示这一点。
-
-**从源码安装**（想跟进 `main` 或改代码）：`git clone https://github.com/JialaoLiu/dsh-baton.git`，再运行 `node dsh-baton/src/cli.mjs setup`。这时 setup 注册的就是克隆目录本身，插件也从克隆目录的 `host` 文件夹添加（添加插件 → 粘贴它复制的路径），这样插件改动在发布前就能跑起来；更新用 `git pull`。
+插件启用后会为 Claude Code 和 Codex 注册 dsh-baton（对所有文件夹生效），Harness 里会弹出提示。
 
-<details>
-<summary>手动注册与 Claude 桌面应用</summary>
-
-`setup` 写入的内容和下面两条命令等价（用 `node` 的绝对路径，因为桌面应用启动 MCP 服务器时没有你 shell 的 `PATH`）：
-
-```bash
-claude mcp add dsh-baton -s user -- "$(command -v node)" "$PWD/dsh-baton/src/server.mjs"
-codex mcp add dsh-baton -- "$(command -v node)" "$PWD/dsh-baton/src/server.mjs"
-```
-
-`-s user` 很关键：不加的话，Claude Code 只给当前项目文件夹注册。
-
-**Claude 桌面应用（可选）**：聊天应用的连接器（和 Claude Code 是两回事），把下面这段加到 `~/Library/Application Support/Claude/claude_desktop_config.json`，然后重启应用，会显示为 "Local dev" 连接器。
-
-```json
-{ "mcpServers": { "dsh-baton": { "command": "/node 的绝对路径", "args": ["/dsh-baton 的绝对路径/src/server.mjs"] } } }
-```
+**2. 检查：**在 Claude Code 或 Codex 里**新开**一个对话，让它调用 `dsh_list_workspaces`，会列出你的 Harness 工作区。
 
-</details>
+就这些。如果 Harness 提示没能注册（比如找不到 Node.js），在终端运行 `npx -y dsh-baton-mcp setup`，它做的是同样的注册。更新、卸载和 Windows 说明在[后面](#安装细节)。
 
 ## 工作原理
 
@@ -106,6 +60,11 @@ codex mcp add dsh-baton -- "$(command -v node)" "$PWD/dsh-baton/src/server.mjs"
   <img src="./assets/readme/zh/comparison.svg" width="100%" alt="插件和 headless 对比：只有插件能在 Harness 界面实时可见、续接桌面版的对话、使用桌面版智能体预设；两者都沿用桌面版登录">
 </p>
 
+**各客户端怎么等待**（不需要配置）：
+- **Claude Code** 在后台等待任务（`dsh_send` 返回的 `wait_command`），任务结束时只被唤醒一次。
+- **Codex** 在 `dsh_wait` 里等待，每次最多 270 秒，刚好低于它 300 秒的工具超时。没做完时只返回状态，Codex 会直接再调用，不会去总结进度。Codex 不会收到 `wait_command`：它的终端无法在命令结束时唤醒它，只能轮询。
+- Codex 调用 MCP 工具时会请你批准，批准 `dsh-baton` 的工具即可；无人值守的 `codex exec` 加上 `--approve-for-me`。
+
 ## 工具
 
 <p align="center">
@@ -175,6 +134,42 @@ dsh-baton rename-workspace ~/code/new-app 新名字
 
 </details>
 
+## 安装细节
+
+**插件启用时做了什么。**它把 MCP 服务器复制到 `~/.dsh-baton/app` 这个固定的文件夹，再直接把 MCP 注册写进 `~/.claude.json` 和 `~/.codex/config.toml`，各留一份 `*.bak-dsh-baton` 备份。注册的是 `PATH` 里找到的 `node`（不会用 Harness 自带的那个），所以只装了桌面应用、`claude` / `codex` 不在 `PATH` 里也能用。每次 Harness 启动都会再检查一遍：已经正确的注册、或者指向另一份可用 dsh-baton 的注册，都不会改动。在 Harness 里输入包名后，安装源会自动切到「npm 官方源」（英文界面是 "Official npm registry"），不用另外选择，也不用重启。不想让插件自动注册，给 Harness 设置 `DSH_BATON_AUTO_REGISTER=0`。
+
+**`npx -y dsh-baton-mcp setup`** 在终端里做同样的注册：用于插件没能注册的情况，或者从 MCP 目录过来的用户。插件已经注册过时它什么都不改；插件没装的话，它会提示去添加。
+
+**更新。**Harness 只给官方插件提供"更新"按钮，所以要：插件 → dsh-baton-host → **卸载**，再**添加插件** → `dsh-baton-host`。新版本刚发布的一段时间里，Harness 会装上一个版本（pnpm 的 `minimumReleaseAge` 会暂缓刚发布的版本，安装弹窗里会说明）；想马上用新版，输入带版本号的名字：`dsh-baton-host@0.5.0`。重新启用后，插件会把 MCP 服务器也更新到同一版本，新开的对话就会用上。万一两边版本对不上，第一次发现不一致的工具调用会提示。
+
+**卸载。**Harness → 插件 → dsh-baton-host → **卸载**，再运行 `npx -y dsh-baton-mcp setup --remove`。插件分不清"被卸载"和"Harness 退出"，所以 MCP 注册交给这条命令删，它也会删掉 `~/.dsh-baton/app`；运行记录留在 `~/.dsh-baton`，不需要的话自己删掉。
+
+**从 dsh-bridge 升级。**在 Harness 里先卸载 `dsh-bridge-host`，再添加 `dsh-baton-host`；启用后它会替换掉旧的 `dsh-bridge` MCP 注册。`DSH_BRIDGE_*` 环境变量和已有的 `~/.dsh-bridge` 文件夹暂时继续可用。工具前缀变成 `mcp__dsh-baton__…`，权限白名单里写了旧前缀的要改一下。0.4 之前通过粘贴 `~/.dsh-baton/app/host` 装的插件仍然能用，但不会跟着 npm 更新：卸载它，再按包名添加 `dsh-baton-host`。
+
+**从源码安装**（想跟进 `main` 或改代码）：`git clone https://github.com/JialaoLiu/dsh-baton.git`，然后在 Harness 里从克隆目录的 `host` 文件夹添加插件（添加插件 → 粘贴路径）。启用后注册的就是克隆目录本身，改动在发布前就能跑起来；更新用 `git pull`。在终端里运行 `node dsh-baton/src/cli.mjs setup` 也能注册克隆目录。
+
+**Windows。**步骤相同；[WINDOWS.md](WINDOWS.md) 说明了不同之处（用命名管道代替套接字文件），以及插件页装不上或卸不掉时的修法。
+
+<details>
+<summary>手动注册与 Claude 桌面应用</summary>
+
+插件和 `setup` 写入的内容和下面两条命令等价（用 `node` 的绝对路径，因为桌面应用启动 MCP 服务器时没有你 shell 的 `PATH`）：
+
+```bash
+claude mcp add dsh-baton -s user -- "$(command -v node)" "$PWD/dsh-baton/src/server.mjs"
+codex mcp add dsh-baton -- "$(command -v node)" "$PWD/dsh-baton/src/server.mjs"
+```
+
+`-s user` 很关键：不加的话，Claude Code 只给当前项目文件夹注册。
+
+**Claude 桌面应用（可选）**：聊天应用的连接器（和 Claude Code 是两回事），把下面这段加到 `~/Library/Application Support/Claude/claude_desktop_config.json`，然后重启应用，会显示为 "Local dev" 连接器。
+
+```json
+{ "mcpServers": { "dsh-baton": { "command": "/node 的绝对路径", "args": ["/dsh-baton 的绝对路径/src/server.mjs"] } } }
+```
+
+</details>
+
 ## 安全与限制
 
 <p align="center">

package/WINDOWS.md

@@ -20,25 +20,11 @@ Verified on Windows 11 with DeepSeek Harness 0.2.1-rc.2 (desktop app), Node.js 2
 
 ## Install
 
-Requires DeepSeek Harness ≥ 0.2.1-rc.2 and Node.js ≥ 22.15. In PowerShell:
+Exactly as in the [README](README.md#quick-start): in Harness add the plugin `dsh-baton-host` and switch it on. Updating and removing are the same too ([Install details](README.md#install-details)). On Windows:
 
-```powershell
-npx -y dsh-baton-mcp setup
-```
-
-`setup` copies itself to `%USERPROFILE%\.dsh-baton\app` (npx's cache is not a stable place) and registers the MCP server once, user-wide, for Claude Code (`%USERPROFILE%\.claude.json`) and Codex (`%USERPROFILE%\.codex\config.toml`), with the absolute path of `node`. It edits the files directly, so it works with the desktop apps alone: their `claude.exe` / `codex.exe` are usually not on `PATH`. It also copies the plugin's package name to the clipboard.
-
-Then, in Harness: **Plugins / 插件** → **Add plugin / 添加插件** → registry **Official npm registry** → `dsh-baton-host` → **Install / 安装** → **Enable now / 立即启用**. The pipe appears right away (see [Verify](#verify)); if it does not, restart Harness.
-
-Nothing else to configure: Claude Code waits for a run in the background (Git Bash runs the `wait_command` that `dsh_send` returns), and Codex waits up to 270 s per `dsh_wait` call, under its 300 s tool timeout. Approve the `dsh-baton` tools when Codex asks; for unattended `codex exec`, add `--approve-for-me`.
-
-Update: `npx -y dsh-baton-mcp@latest setup` for the MCP server; for the plugin, Harness → Plugins → dsh-baton-host → Uninstall, then Add plugin → `dsh-baton-host` again (Harness has no update button for non-official plugins).
-
-Remove: Harness → Plugins → dsh-baton-host → Uninstall, and `npx -y dsh-baton-mcp setup --remove`.
-
-Upgrading from dsh-bridge: `setup` replaces the old MCP entries and reuses an existing `%USERPROFILE%\.dsh-bridge` (the app then goes to `.dsh-bridge\app`). Uninstall `dsh-bridge-host` in Harness, then add `dsh-baton-host` by name. A plugin added earlier from `.dsh-baton\app\host` (0.3) also works, but `setup` suggests swapping it for the npm package, which is the one that gets updates. With the hoisted profile layout, uninstalling may leave a `node_modules\dsh-bridge-host` link behind in `%USERPROFILE%\.dsh\profiles\desktop`; `setup --remove` deletes such a leftover link (old or new name) once the profile no longer lists the plugin.
-
-From source instead: `git clone https://github.com/JialaoLiu/dsh-baton.git C:\dev\dsh-baton` and `node C:\dev\dsh-baton\src\cli.mjs setup`; setup then has you add the plugin from `C:\dev\dsh-baton\host` (Add plugin → paste the path it copies).
+- Switched on, the plugin copies the MCP server to `%USERPROFILE%\.dsh-baton\app` and writes `%USERPROFILE%\.claude.json` and `%USERPROFILE%\.codex\config.toml` with the absolute path of `node.exe` (from `PATH`, `%ProgramFiles%\nodejs` or nvm-windows' `NVM_SYMLINK`; never Harness's own runtime), so the desktop apps work even though their `claude.exe` / `codex.exe` are usually not on `PATH`. If it reports that it could not register, run `npx -y dsh-baton-mcp setup` in PowerShell.
+- Claude Code runs the background `wait_command` in Git Bash.
+- With the hoisted profile layout, uninstalling a plugin can leave a `node_modules\dsh-baton-host` (or old `dsh-bridge-host`) link in `%USERPROFILE%\.dsh\profiles\desktop`; `setup --remove` deletes it once the profile no longer lists the plugin.
 
 ### If the Plugins page cannot uninstall or install it
 
@@ -109,7 +95,7 @@ The suite runs on Windows with named pipes. Two POSIX-only checks are skipped: f
 
 - **套接字改为命名管道。** Windows 上 Node 不能监听 Unix 套接字文件，所以同一路径被映射成按用户区分的命名管道 `\\.\pipe\dsh-baton-<哈希>`。插件和 MCP 两边算法一致，`DSH_BATON_SOCKET` 仍然可用，Harness 退出后管道自动消失。
 - **headless 用 Harness 自带的 CLI。** Harness ≥ 0.2.1 自带 `resources\runtime\cli\bin\dsh.cmd`；更早的版本只有打包在 `app.asar` 里的 CLI，由 Harness 自己的 exe 以 Node 模式运行。会按顺序自动查找：`DSH_BIN`、`PATH` 里的 `dsh`、默认安装位置，以及注册表里的自定义安装目录。
-- **插件用 Harness 插件页按包名安装。** 插件 → 添加插件 → 来源选 Official npm registry → 输入 `dsh-baton-host` → 安装 → 立即启用（`setup` 已把包名复制到剪贴板）。更新插件要先卸载再重新添加，Harness 只给官方插件提供更新按钮。
-- **一条命令注册 MCP。** `npx -y dsh-baton-mcp setup` 把自己复制到 `%USERPROFILE%\.dsh-baton\app`，再直接写 Claude Code 和 Codex 的用户级配置（用 `node` 的绝对路径），桌面版的 `claude` / `codex` 不在 `PATH` 里也没关系。之后新开对话就有 `dsh_*` 工具；Codex 每次最多等 270 秒，不用再配超时。
+- **安装和 macOS 完全相同。** 在 Harness 插件页添加 `dsh-baton-host` 并启用，详见 [README](README.zh-CN.md#快速上手)。
+- **插件启用时自动注册 MCP。** 它把 MCP 服务器复制到 `%USERPROFILE%\.dsh-baton\app`，再直接写 Claude Code 和 Codex 的用户级配置（用 `PATH`、`%ProgramFiles%\nodejs` 或 nvm-windows 里找到的 `node.exe` 绝对路径，不用 Harness 自带的），桌面版的 `claude` / `codex` 不在 `PATH` 里也没关系。之后新开对话就有 `dsh_*` 工具；Codex 每次最多等 270 秒，不用再配超时。没能注册时，在 PowerShell 里运行 `npx -y dsh-baton-mcp setup`。
 - **插件页卸不掉或装不上时**（`ERR_PNPM_UNEXPECTED_STORE`，或提示"该插件已安装"）：是旧版 Harness 装 profile 时用了另一个 pnpm store。一次性修好：从菜单退出 Harness，把 `%USERPROFILE%\.dsh\profiles\desktop\node_modules` 改名备份，用 Harness 自带的 pnpm 运行 `install --frozen-lockfile`（不加 `--store-dir`；`$app` 改成你的安装目录，比如 `E:\Software\DeepSeek Harness`），再启动 Harness，插件页的卸载和添加就正常了；如果插件被关掉了，记得重新打开。
 - **headless 需要独立凭据。** 要么登录账户，要么设置 `DEEPSEEK_API_KEY`。桌面版里保存的 Key，headless CLI 读不到。

package/host/README.md

@@ -6,11 +6,15 @@ DeepSeek Harness 插件，配合 [dsh-baton](https://github.com/JialaoLiu/dsh-ba
 
 ## Install / 安装
 
-Harness → Plugins / 插件 → Add plugin / 添加插件 → registry Official npm registry → `dsh-baton-host` → Install / 安装 → Enable now / 立即启用
+Harness → Plugins / 插件 → Add plugin / 添加插件 → `dsh-baton-host` → Install / 安装 → Enable now / 立即启用
 
-Update / 更新: uninstall, then add it again / 先卸载再重新添加. Keep it on the same version as `dsh-baton-mcp` / 版本与 `dsh-baton-mcp` 保持一致.
+That is the whole install: switched on, the plugin registers the dsh-baton MCP server (the `dsh-baton-mcp` package, installed with it) for Claude Code and Codex, user-wide, and Harness says so. New conversations then have the `dsh_*` tools. If it could not register, run `npx -y dsh-baton-mcp setup`. Details: [dsh-baton](https://github.com/JialaoLiu/dsh-baton#install-details).
 
-Then connect the MCP server / 然后接入 MCP 服务器: see [dsh-baton](https://github.com/JialaoLiu/dsh-baton#readme).
+装好就完成了：插件启用时会为 Claude Code 和 Codex 注册 dsh-baton MCP 服务器（`dsh-baton-mcp` 包，随插件一起安装），Harness 里会提示。新开的对话就有 `dsh_*` 工具。没能注册的话，运行 `npx -y dsh-baton-mcp setup`。详见 [dsh-baton](https://github.com/JialaoLiu/dsh-baton/blob/main/README.zh-CN.md#安装细节)。
+
+Update / 更新: uninstall, then add it again; the MCP server is updated with it / 先卸载再重新添加，MCP 服务器会一起更新.
+
+Remove / 卸载: uninstall, then `npx -y dsh-baton-mcp setup --remove` / 卸载插件后运行 `npx -y dsh-baton-mcp setup --remove`.
 
 ## Socket protocol / 套接字协议
 
@@ -32,7 +36,9 @@ Newline-delimited JSON: request `{"id", "method", "params"}`, reply `{"id", "res
 | `rename_workspace` | `workspace_id` or `path`, `title` |
 | `list_runs` | `limit?` |
 
-`DSH_BATON_SOCKET` / `DSH_BATON_HOME` in the Harness process environment move the socket.
+`DSH_BATON_SOCKET` / `DSH_BATON_HOME` in the Harness process environment move the socket. `DSH_BATON_AUTO_REGISTER=0` turns off the MCP registration.
+
+The Plugins page reads the registration outcome from `GET /dsh-baton/status` on the Harness web server.
 
 ## License
 

package/host/lib/client.js

@@ -1,5 +1,9 @@
-// dsh-baton-host, browser half: labels chat messages sent through dsh-baton with
-// their sender ("Sent by Claude from another chat"). The host half puts the sender
+// dsh-baton-host, browser half. Two jobs:
+//   - On the Plugins page: right after the plugin is switched on, and on its detail page,
+//     say whether the host half registered the MCP server for Claude Code and Codex
+//     (it serves the outcome at /dsh-baton/status).
+//   - In the chat: label messages sent through dsh-baton with their sender ("Sent by
+//     Claude from another chat"). The host half puts the sender
 // into the prompt's request id ("dsh-baton.<sender>.<uuid>"); the chat records it as
 // the user message's source.rpcId, so the label survives reloads with no extra state.
 //
@@ -14,7 +18,10 @@ window.__ModuleLoader__.load({
   id: 'dsh-baton-host',
   factory: (require) => {
     const module = { exports: {} }
-    const { createElement: h } = require('react')
+    const { createElement: h, useState, useEffect } = require('react')
+    // Harness's dialog and button; without them (an older or newer Harness), plain elements.
+    let ui = null
+    try { ui = require('@deepseek-ai/dsh-client-ui-primitives') } catch { /* fall back */ }
 
     const SLOT = 'conversation.chat.node'
     const KEYS = ['user', 'steering']
@@ -25,8 +32,124 @@ window.__ModuleLoader__.load({
     // Codex shows as ChatGPT, the way the ChatGPT app labels its own cross-chat messages.
     const NAMES = { claude: 'Claude', codex: 'ChatGPT' }
 
-    const zh = { sentFrom: '由 {name} 从另一个聊天发送' }
-    const en = { sentFrom: 'Sent by {name} from another chat' }
+    const PACKAGE = 'dsh-baton-host'
+    const SETUP = 'npx -y dsh-baton-mcp setup'
+
+    const zh = {
+      sentFrom: '由 {name} 从另一个聊天发送',
+      readyTitle: 'dsh-baton 已就绪',
+      failTitle: 'dsh-baton 还差一步',
+      pending: '正在为 Claude Code 和 Codex 注册 dsh-baton…',
+      ready: '已为 {clients} 注册 dsh-baton。在 Claude Code 或 Codex 里新开一个对话，就能用 dsh_* 工具。',
+      partial: '{clients} 没能注册：',
+      noNode: '没找到 Node.js 22.15 或更新版本。装好 Node.js 后，',
+      noClients: '没找到 Claude Code 或 Codex。装好之后，',
+      failed: '没能自动注册 MCP。',
+      runSetup: '请在终端运行 {cmd}。',
+      unknown: '如果新对话里没有 dsh_* 工具，请在终端运行 {cmd}。',
+      off: '已关闭自动注册（DSH_BATON_AUTO_REGISTER=0）。',
+      ok: '知道了',
+      status: 'MCP 注册',
+      registered: '已注册',
+      notInstalled: '未安装',
+      notRegistered: '未注册',
+      and: '和',
+    }
+    const en = {
+      sentFrom: 'Sent by {name} from another chat',
+      readyTitle: 'dsh-baton is ready',
+      failTitle: 'dsh-baton needs one more step',
+      pending: 'Registering dsh-baton for Claude Code and Codex…',
+      ready: 'dsh-baton is registered for {clients}. Start a new conversation in Claude Code or Codex to use the dsh_* tools.',
+      partial: 'Could not register for {clients}: ',
+      noNode: 'Node.js 22.15 or later was not found. Once it is installed, ',
+      noClients: 'Neither Claude Code nor Codex was found. Once one is installed, ',
+      failed: 'The MCP server could not be registered automatically. ',
+      runSetup: 'run {cmd} in a terminal.',
+      unknown: 'If new conversations have no dsh_* tools, run {cmd} in a terminal.',
+      off: 'Automatic registration is off (DSH_BATON_AUTO_REGISTER=0).',
+      ok: 'OK',
+      status: 'MCP registration',
+      registered: 'registered',
+      notInstalled: 'not installed',
+      notRegistered: 'not registered',
+      and: 'and',
+    }
+
+    // --- Plugins page ------------------------------------------------------------
+
+    const statusUrl = () => new URL('dsh-baton/status', document.baseURI).pathname
+    const REGISTERED = ['registered', 'unchanged', 'kept']
+
+    // The host half registers right after it starts, so poll until it says it is done.
+    function useRegistration() {
+      const [reg, setReg] = useState(null)
+      useEffect(() => {
+        let stopped = false
+        let tries = 0
+        const poll = async () => {
+          let next = null
+          try {
+            const res = await fetch(statusUrl(), { cache: 'no-store' })
+            if (res.ok) next = (await res.json()).registration
+          } catch { /* not served yet */ }
+          if (stopped) return
+          if (next && next.state !== 'pending') return setReg(next)
+          if (++tries >= 30) return setReg({ state: 'unknown' })
+          setTimeout(poll, 700)
+        }
+        poll()
+        return () => { stopped = true }
+      }, [])
+      return reg
+    }
+
+    // What to tell the user: [title or null, text]. null while the host is still working.
+    function describe(reg, t) {
+      if (!reg || reg.state === 'pending') return [null, t('pending')]
+      if (reg.state === 'off') return [t('readyTitle'), t('off')]
+      if (reg.state === 'unknown') return [t('readyTitle'), t('unknown', { cmd: SETUP })]
+      const clients = reg.clients ?? []
+      const done = clients.filter((c) => REGISTERED.includes(c.state)).map((c) => c.label)
+      const failed = clients.filter((c) => c.state === 'failed').map((c) => c.label)
+      const list = (names) => names.join(` ${t('and')} `)
+      const fix = (reg.error === 'no-node' ? t('noNode') : reg.error === 'no-clients' ? t('noClients') : '') + t('runSetup', { cmd: SETUP })
+      if (reg.ok) return [t('readyTitle'), t('ready', { clients: list(done) })]
+      if (done.length) return [t('failTitle'), `${t('ready', { clients: list(done) })} ${t('partial', { clients: list(failed) })}${fix}`]
+      return [t('failTitle'), (reg.error === 'no-node' || reg.error === 'no-clients' ? '' : t('failed')) + fix]
+    }
+
+    // Shown once, right after "Enable now".
+    function wrapActivation(t) {
+      return function DshBatonActivation({ onDismiss }) {
+        const [title, text] = describe(useRegistration(), t)
+        if (ui?.Modal && ui?.Button) {
+          return h(ui.Modal, {
+            open: true, title: title ?? t('readyTitle'), closeLabel: t('ok'), onClose: onDismiss,
+            footer: h(ui.Button, { variant: 'primary', 'data-modal-autofocus': true, onClick: onDismiss }, t('ok')),
+          }, h('p', null, text))
+        }
+        return h('div', { role: 'status', style: { margin: '12px 0', padding: 12, borderRadius: 8, border: '1px solid var(--dsw-alias-border-l3)', color: 'var(--dsw-alias-label-primary)' } },
+          title ? h('strong', null, title) : null,
+          h('p', { style: { margin: '6px 0' } }, text),
+          h('button', { type: 'button', onClick: onDismiss }, t('ok')))
+      }
+    }
+
+    // The plugin's detail page: one line per client.
+    function wrapDetails(t) {
+      return function DshBatonStatus({ view }) {
+        const reg = useRegistration()
+        if (view === 'summary') return null
+        const [, text] = describe(reg, t)
+        const word = (s) => (REGISTERED.includes(s) ? t('registered') : s === 'not-installed' ? t('notInstalled') : t('notRegistered'))
+        const rows = (reg?.clients ?? []).map((c) => `${c.label}: ${word(c.state)}`)
+        return h('div', { style: { display: 'flex', flexDirection: 'column', gap: 4, color: 'var(--dsw-alias-label-secondary)' } },
+          h('strong', { style: { color: 'var(--dsw-alias-label-primary)' } }, t('status')),
+          rows.length ? h('span', null, rows.join(' · ')) : null,
+          h('span', null, text))
+      }
+    }
 
     function senderOf(node) {
       const rpcId = node?.data?.source?.rpcId
@@ -92,6 +215,8 @@ window.__ModuleLoader__.load({
         // locale 'chat': the shipped renderer reads its strings through the `t` it is handed.
         for (const key of KEYS) yield ctx.slots.register({ name: SLOT, key, priority: PRIORITY, locale: 'chat' }, wrapperFor(ctx, key, t))
       })
+      ctx.slots.inject('plugins.bundle.activation', () => ctx.slots.register({ name: 'plugins.bundle.activation', key: PACKAGE, locale: NS }, wrapActivation(t)))
+      ctx.slots.inject('plugins.bundle.config', () => ctx.slots.register({ name: 'plugins.bundle.config', key: PACKAGE, locale: NS }, wrapDetails(t)))
     }
     return module.exports
   },

package/host/lib/index.js

@@ -10,7 +10,9 @@ import net from 'node:net'
 import os from 'node:os'
 import path from 'node:path'
 import crypto from 'node:crypto'
-import { socketEndpoint, batonHome, socketPath as socketPathSetting } from './socket.js'
+import { createRequire } from 'node:module'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { socketEndpoint, batonHome, setting, socketPath as socketPathSetting } from './socket.js'
 
 export const name = 'dsh-baton-host'
 export const inject = ['sessionController', 'workspaceRegistry']
@@ -85,6 +87,26 @@ function toolCallsOf(content) {
 
 const iso = (t) => (typeof t === 'number' ? new Date(t).toISOString() : t ?? null)
 
+// The MCP server package this plugin registers: the checkout or ~/.dsh-baton/app folder
+// this host folder sits in, else the dsh-baton-mcp package installed with the plugin.
+function serverRoot() {
+  const up = fileURLToPath(new URL('../../', import.meta.url))
+  if (fs.existsSync(path.join(up, 'src', 'register.mjs'))) return path.resolve(up)
+  try { return path.dirname(createRequire(import.meta.url).resolve('dsh-baton-mcp/package.json')) } catch { return null }
+}
+
+// The Harness install this process runs from, so its bundled Node (whose path changes
+// with every Harness update) is never registered.
+function harnessDir() {
+  const exe = process.execPath
+  const app = exe.match(/^(.*?\.app)(?=[\\/])/)
+  if (app) return app[1]
+  // Windows: the install folder, e.g. %LOCALAPPDATA%\Programs\DeepSeek Harness.
+  const i = exe.toLowerCase().indexOf('deepseek harness')
+  const end = i < 0 ? -1 : exe.slice(i).search(/[\\/]/)
+  return end > 0 ? exe.slice(0, i + end) : null
+}
+
 export function apply(ctx) {
   // This code runs inside the Harness host process: an uncaught error here can
   // take Harness down. Every event listener and timer goes through guard().
@@ -630,6 +652,40 @@ export function apply(ctx) {
   }
 
 
+  // --- MCP registration -----------------------------------------------------
+  // Switching the plugin on registers the dsh-baton MCP server for Claude Code and Codex,
+  // the same entries `dsh-baton setup` writes, so adding the plugin is the whole install.
+  // It runs again on every Harness start: a plugin update brings the server along, and an
+  // entry that is already right is left untouched. The Plugins page reads the outcome from
+  // GET /dsh-baton/status (lib/client.js). DSH_BATON_AUTO_REGISTER=0 turns it off.
+  let registration = { state: 'pending' }
+  if (setting('AUTO_REGISTER') !== '0') {
+    setImmediate(guard('register', async () => {
+      const root = serverRoot()
+      if (!root) { registration = { state: 'done', ok: false, error: 'no-server', clients: [] }; return }
+      const { autoRegister } = await import(pathToFileURL(path.join(root, 'src', 'register.mjs')).href)
+      const result = autoRegister({ root, harnessDir: harnessDir() })
+      registration = { state: 'done', ...result }
+      const summary = result.clients.map((c) => `${c.label}: ${c.state}${c.error ? ` (${c.error})` : ''}`).join(', ')
+      ctx.logger?.[result.ok ? 'info' : 'error']?.(`dsh-baton-host MCP registration: ${summary || result.error}`)
+    }))
+  } else {
+    registration = { state: 'off' }
+  }
+  if (typeof ctx.inject === 'function') {
+    ctx.inject(['webServer'], (web) => {
+      web.effect(() => web.webServer.register({
+        kind: 'exact',
+        path: '/dsh-baton/status',
+        handler: (request, response) => {
+          const { state, ok, error, version, clients = [] } = registration
+          response.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' })
+          response.end(JSON.stringify({ version: VERSION, registration: { state, ok, error, version, clients: clients.map(({ id, label, state }) => ({ id, label, state })) } }))
+        },
+      }), 'dsh-baton-host status route')
+    })
+  }
+
   ctx.effect(() => {
     const sock = socketPath()
     let server = null

package/host/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-baton-host",
-  "version": "0.4.0",
-  "description": "DeepSeek Harness plugin for dsh-baton: takes the baton from Claude Code or Codex over a local, owner-only control socket, runs it in a specific session through the host's own session controller, and hands the result back when the turn is done.",
+  "version": "0.5.1",
+  "description": "DeepSeek Harness plugin for dsh-baton: adding it is the whole install. Switched on, it registers the dsh-baton MCP server for Claude Code and Codex, then takes the baton over a local, owner-only control socket, runs it in a specific session through the host's own session controller, and hands the result back when the turn is done.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -19,6 +19,9 @@
     "README.md",
     "LICENSE"
   ],
+  "dependencies": {
+    "dsh-baton-mcp": "0.5.1"
+  },
   "license": "MIT",
   "dsh": {
     "manifestVersion": 1,
@@ -33,7 +36,8 @@
       "inject": [
         "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-renderer",
-        "@deepseek-ai/dsh-client-ui-chat"
+        "@deepseek-ai/dsh-client-ui-chat",
+        "@deepseek-ai/dsh-client-ui-primitives"
       ]
     }
   },

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "dsh-baton-mcp",
-  "version": "0.4.0",
+  "version": "0.5.1",
+  "mcpName": "io.github.JialaoLiu/dsh-baton",
   "description": "Pass the baton from Claude Code, Codex or any MCP client to a local DeepSeek Harness: an MCP server that hands off tasks, continues a specific session, shows the run live in Harness and hands the result back when it is done.",
   "type": "module",
   "bin": {
@@ -18,7 +19,8 @@
     "README.md",
     "README.zh-CN.md",
     "WINDOWS.md",
-    "LICENSE"
+    "LICENSE",
+    "server.json"
   ],
   "engines": {
     "node": ">=22.15"

package/server.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.JialaoLiu/dsh-baton",
+  "title": "dsh-baton",
+  "description": "Hand tasks from Claude Code, Codex or any MCP client to a local DeepSeek Harness.",
+  "repository": {
+    "url": "https://github.com/JialaoLiu/dsh-baton",
+    "source": "github"
+  },
+  "version": "0.5.1",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "dsh-baton-mcp",
+      "version": "0.5.1",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}

package/src/register.mjs

@@ -0,0 +1,236 @@
+// Registering the dsh-baton MCP server for Claude Code and Codex, user-wide, by writing
+// their config files directly. This needs no `claude` or `codex` on PATH (desktop-only
+// installs have neither) and no hand-editing of TOML.
+//
+// Two callers: `dsh-baton setup` (src/setup.mjs), and the Harness plugin, which runs
+// autoRegister() when it is switched on. So this module imports nothing that does work
+// at load time: it runs inside the Harness host process as well.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { execFileSync } from 'node:child_process'
+import { batonHome } from '../host/lib/socket.js'
+
+export const NAME = 'dsh-baton'
+// The name before the rename: its entries are removed so the tools are not listed twice.
+const OLD_NAME = 'dsh-bridge'
+
+export const claudeConfigPath = (env = process.env, home = os.homedir()) =>
+  path.join(env.CLAUDE_CONFIG_DIR || home, '.claude.json')
+export const codexConfigPath = (env = process.env, home = os.homedir()) =>
+  path.join(env.CODEX_HOME || path.join(home, '.codex'), 'config.toml')
+
+// ~/.claude.json: the top-level "mcpServers" map is Claude Code's user scope.
+export function editClaudeConfig(text, entry) {
+  const cfg = text.trim() ? JSON.parse(text) : {}
+  const servers = { ...(cfg.mcpServers ?? {}) }
+  delete servers[OLD_NAME]
+  if (entry) servers[NAME] = { type: 'stdio', command: entry.command, args: entry.args, env: {} }
+  else delete servers[NAME]
+  return JSON.stringify({ ...cfg, mcpServers: servers }, null, 2) + '\n'
+}
+
+export function readClaudeEntry(text) {
+  const e = text.trim() ? JSON.parse(text).mcpServers?.[NAME] : null
+  return e?.command ? { command: e.command, args: e.args ?? [] } : null
+}
+
+const tomlString = (s) => (/['\n\r]/.test(s) ? JSON.stringify(s) : `'${s}'`)
+// Our own table and its sub-tables ([mcp_servers.dsh-baton], [mcp_servers.dsh-baton.env], …),
+// under the current name or the one before the rename.
+const OWN_TABLE = /^\s*\[\s*mcp_servers\s*\.\s*(["']?)dsh-(?:baton|bridge)\1\s*(?:\.[^\]]*)?\]\s*(?:#.*)?$/
+const ANY_TABLE = /^\s*\[/
+
+// ~/.codex/config.toml: replace any earlier dsh-baton tables with one fresh table at the
+// end. Codex stops a tool call after 300 s; the server keeps each wait under that, so no
+// tool_timeout_sec is needed.
+export function editCodexConfig(text, entry) {
+  const kept = []
+  let skipping = false
+  for (const line of text.split(/\r?\n/)) {
+    if (OWN_TABLE.test(line)) skipping = true
+    else if (ANY_TABLE.test(line)) skipping = false
+    if (!skipping) kept.push(line)
+  }
+  let out = kept.join('\n').replace(/\s+$/, '')
+  if (entry) {
+    out += `${out ? '\n\n' : ''}[mcp_servers.${NAME}]\ncommand = ${tomlString(entry.command)}\nargs = [${entry.args.map(tomlString).join(', ')}]`
+  }
+  return out ? out + '\n' : ''
+}
+
+// The command and args of [mcp_servers.dsh-baton], as setup writes them (single-line strings).
+export function readCodexEntry(text) {
+  const str = String.raw`'[^'\n]*'|"(?:[^"\\\n]|\\.)*"`
+  const unquote = (s) => (s.startsWith("'") ? s.slice(1, -1) : JSON.parse(s))
+  let inTable = false
+  let command = null, args = []
+  for (const line of text.split(/\r?\n/)) {
+    if (ANY_TABLE.test(line)) inTable = /^\s*\[\s*mcp_servers\s*\.\s*(["']?)dsh-baton\1\s*\]/.test(line)
+    else if (inTable) {
+      const c = line.match(new RegExp(`^\\s*command\\s*=\\s*(${str})`))
+      if (c) command = unquote(c[1])
+      const a = line.match(/^\s*args\s*=\s*\[(.*)\]/)
+      if (a) args = [...a[1].matchAll(new RegExp(str, 'g'))].map((m) => unquote(m[0]))
+    }
+  }
+  return command ? { command, args } : null
+}
+
+// Write only when the content changes, keep one backup, and replace the file atomically.
+export function rewrite(file, edit) {
+  const before = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : ''
+  const after = edit(before)
+  if (after === before) return 'unchanged'
+  if (before) fs.copyFileSync(file, `${file}.bak-dsh-baton`)
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  const tmp = `${file}.tmp-${process.pid}`
+  fs.writeFileSync(tmp, after, { mode: before ? fs.statSync(file).mode : 0o600 })
+  fs.renameSync(tmp, file)
+  return 'updated'
+}
+
+// Which clients are installed for this user, and where their config lives.
+export function clients(env = process.env, home = os.homedir()) {
+  const claude = claudeConfigPath(env, home)
+  const codex = codexConfigPath(env, home)
+  return [
+    { id: 'claude', label: 'Claude Code', file: claude, present: fs.existsSync(claude) || fs.existsSync(path.join(home, '.claude')), edit: editClaudeConfig, read: readClaudeEntry },
+    { id: 'codex', label: 'Codex', file: codex, present: fs.existsSync(path.dirname(codex)), edit: editCodexConfig, read: readCodexEntry },
+  ]
+}
+
+// The node to register: the one on PATH when it is this same binary, since that path
+// survives upgrades (Homebrew's /opt/homebrew/bin/node, not the versioned Cellar path
+// that process.execPath resolves to); otherwise the running binary itself.
+export function stableNodePath(env = process.env, execPath = process.execPath) {
+  const real = (p) => { try { return fs.realpathSync(p) } catch { return null } }
+  const target = real(execPath)
+  const names = process.platform === 'win32' ? ['node.exe'] : ['node']
+  for (const dir of (env.PATH ?? env.Path ?? '').split(path.delimiter).filter(Boolean)) {
+    for (const name of names) {
+      const candidate = path.join(dir, name)
+      if (candidate !== execPath && target && real(candidate) === target) return candidate
+    }
+  }
+  return execPath
+}
+
+export const MIN_NODE = [22, 15]
+export function nodeVersionOk(version) {
+  const [major, minor] = String(version).replace(/^v/, '').split('.').map(Number)
+  return major > MIN_NODE[0] || (major === MIN_NODE[0] && minor >= MIN_NODE[1])
+}
+
+// A Node.js for the MCP server when the caller is not one itself: the Harness plugin runs
+// on the app's own binary, whose path changes with every Harness update. So: the first
+// `node` on PATH, then the usual install folders, never one inside the Harness app, and
+// only a new enough one.
+export function findNode({ env = process.env, platform = process.platform, exclude = [], version = nodeVersion } = {}) {
+  const exe = platform === 'win32' ? 'node.exe' : 'node'
+  const p = platform === 'win32' ? path.win32 : path.posix
+  const dirs = (env.PATH ?? env.Path ?? '').split(p.delimiter).filter(Boolean)
+  if (platform === 'win32') {
+    dirs.push(...[env.NVM_SYMLINK, env.ProgramFiles && p.join(env.ProgramFiles, 'nodejs'), env.LOCALAPPDATA && p.join(env.LOCALAPPDATA, 'Programs', 'nodejs')].filter(Boolean))
+  } else {
+    dirs.push('/opt/homebrew/bin', '/usr/local/bin', '/usr/bin')
+  }
+  const real = (x) => { try { return fs.realpathSync(x) } catch { return x } }
+  const fold = (s) => (platform === 'win32' ? s.toLowerCase() : s)
+  const skip = exclude.filter(Boolean).map((x) => fold(real(x)))
+  const seen = new Set()
+  for (const dir of dirs) {
+    const candidate = p.join(dir, exe)
+    if (seen.has(candidate)) continue
+    seen.add(candidate)
+    if (!fs.existsSync(candidate)) continue
+    const at = fold(real(candidate))
+    if (skip.some((x) => at === x || at.startsWith(x + p.sep))) continue
+    if (nodeVersionOk(version(candidate))) return candidate
+  }
+  return null
+}
+
+function nodeVersion(bin) {
+  try {
+    return execFileSync(bin, ['--version'], { windowsHide: true, timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], env: { ...process.env, ELECTRON_RUN_AS_NODE: undefined } }).toString().trim()
+  } catch {
+    return ''
+  }
+}
+
+// The stable folder the server runs from when it came from a package cache (npx's, or
+// the Harness profile's): those can be cleared or replaced at any time.
+export const appDir = (home = batonHome()) => path.join(home, 'app')
+const APP_PARTS = ['src', 'host', 'patches', 'package.json', 'LICENSE']
+
+export function installApp(from, to = appDir()) {
+  fs.mkdirSync(to, { recursive: true })
+  for (const part of APP_PARTS) {
+    const src = path.join(from, part)
+    if (!fs.existsSync(src)) continue
+    // Replace each part whole, so files dropped in a newer version do not linger.
+    fs.rmSync(path.join(to, part), { recursive: true, force: true })
+    fs.cpSync(src, path.join(to, part), { recursive: true })
+  }
+  return to
+}
+
+const versionOf = (root) => { try { return JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')).version } catch { return null } }
+export function compareVersions(a, b) {
+  const parse = (v) => String(v).split('-')[0].split('.').map(Number)
+  const [x, y] = [parse(a), parse(b)]
+  for (let i = 0; i < 3; i++) if ((x[i] || 0) !== (y[i] || 0)) return (x[i] || 0) - (y[i] || 0)
+  // A prerelease sorts before its release.
+  return (String(b).includes('-') ? 1 : 0) - (String(a).includes('-') ? 1 : 0)
+}
+
+// Run by the Harness plugin when it is switched on (and on every Harness start, so a
+// plugin update brings the server along). `root` holds the MCP server package: the repo
+// checkout the plugin was added from, or the dsh-baton-mcp package installed with it.
+//   - The server is copied to ~/.dsh-baton/app, unless root is a git checkout (registered
+//     as is, like `setup` from a clone) or that copy is already as new.
+//   - An entry that already starts this server, or a working one that starts another copy
+//     (a clone, say), is left alone; a missing or broken one is (re)written.
+// Never throws: the result says what happened to each client.
+export function autoRegister({ root, home = os.homedir(), env = process.env, node = null, harnessDir = null, find = findNode, app = appDir(batonHome(env, home)) } = {}) {
+  const result = { ok: false, version: versionOf(root), clients: [], error: null, node: null }
+  try {
+    let serverRoot = root
+    if (!fs.existsSync(path.join(root, '.git')) && path.resolve(root) !== path.resolve(app)) {
+      const installed = versionOf(app)
+      if (!installed || !fs.existsSync(path.join(app, 'src', 'server.mjs')) || compareVersions(installed, result.version) < 0) installApp(root, app)
+      serverRoot = app
+    }
+    const script = path.join(serverRoot, 'src', 'server.mjs')
+    const works = (e) => e && fs.existsSync(e.command) && e.args?.[0] && fs.existsSync(e.args[0])
+    const list = clients(env, home)
+    let bin = node
+    for (const c of list) {
+      if (!c.present) { result.clients.push({ id: c.id, label: c.label, state: 'not-installed' }); continue }
+      try {
+        const text = fs.existsSync(c.file) ? fs.readFileSync(c.file, 'utf8') : ''
+        const current = c.read(text)
+        if (works(current)) {
+          const same = path.resolve(current.args[0]) === path.resolve(script)
+          result.clients.push({ id: c.id, label: c.label, state: same ? 'unchanged' : 'kept', script: current.args[0] })
+          continue
+        }
+        bin ??= find({ env, exclude: [harnessDir] })
+        if (!bin) { result.clients.push({ id: c.id, label: c.label, state: 'failed', error: 'no-node' }); continue }
+        rewrite(c.file, (t) => c.edit(t, { command: bin, args: [script] }))
+        result.clients.push({ id: c.id, label: c.label, state: 'registered' })
+      } catch (e) {
+        result.clients.push({ id: c.id, label: c.label, state: 'failed', error: e.message })
+      }
+    }
+    result.node = bin
+    const present = result.clients.filter((c) => c.state !== 'not-installed')
+    result.ok = present.length > 0 && present.every((c) => c.state !== 'failed')
+    if (!present.length) result.error = 'no-clients'
+    else if (present.some((c) => c.error === 'no-node')) result.error = 'no-node'
+  } catch (e) {
+    result.error = e.message
+  }
+  return result
+}

package/src/setup.mjs

@@ -1,67 +1,13 @@
-// One-step setup: register the dsh-baton MCP server for Claude Code and Codex, user-wide,
-// by writing their config files directly. This needs no `claude` or `codex` on PATH
-// (desktop-only installs have neither) and no hand-editing of TOML.
+// `dsh-baton setup`: register the dsh-baton MCP server for Claude Code and Codex, user-wide
+// (see register.mjs, which the Harness plugin also uses), and say what is left to do in Harness.
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { execFileSync } from 'node:child_process'
 import { ROOT, config, hostAvailable, hostVersionSeen as versionOfHost, versionWarning } from './core.mjs'
+import { appDir, installApp, rewrite, stableNodePath, claudeConfigPath, codexConfigPath, editClaudeConfig, editCodexConfig } from './register.mjs'
 
-const NAME = 'dsh-baton'
-// The name before the rename: setup removes its entries so the tools are not listed twice.
-const OLD_NAME = 'dsh-bridge'
-
-export const claudeConfigPath = (env = process.env, home = os.homedir()) =>
-  path.join(env.CLAUDE_CONFIG_DIR || home, '.claude.json')
-export const codexConfigPath = (env = process.env, home = os.homedir()) =>
-  path.join(env.CODEX_HOME || path.join(home, '.codex'), 'config.toml')
-
-// ~/.claude.json: the top-level "mcpServers" map is Claude Code's user scope.
-export function editClaudeConfig(text, entry) {
-  const cfg = text.trim() ? JSON.parse(text) : {}
-  const servers = { ...(cfg.mcpServers ?? {}) }
-  delete servers[OLD_NAME]
-  if (entry) servers[NAME] = { type: 'stdio', command: entry.command, args: entry.args, env: {} }
-  else delete servers[NAME]
-  return JSON.stringify({ ...cfg, mcpServers: servers }, null, 2) + '\n'
-}
-
-const tomlString = (s) => (/['\n\r]/.test(s) ? JSON.stringify(s) : `'${s}'`)
-// Our own table and its sub-tables ([mcp_servers.dsh-baton], [mcp_servers.dsh-baton.env], …),
-// under the current name or the one before the rename.
-const OWN_TABLE = /^\s*\[\s*mcp_servers\s*\.\s*(["']?)dsh-(?:baton|bridge)\1\s*(?:\.[^\]]*)?\]\s*(?:#.*)?$/
-const ANY_TABLE = /^\s*\[/
-
-// ~/.codex/config.toml: replace any earlier dsh-baton tables with one fresh table at the
-// end. Codex stops a tool call after 300 s; the server keeps each wait under that, so no
-// tool_timeout_sec is needed.
-export function editCodexConfig(text, entry) {
-  const kept = []
-  let skipping = false
-  for (const line of text.split(/\r?\n/)) {
-    if (OWN_TABLE.test(line)) skipping = true
-    else if (ANY_TABLE.test(line)) skipping = false
-    if (!skipping) kept.push(line)
-  }
-  let out = kept.join('\n').replace(/\s+$/, '')
-  if (entry) {
-    out += `${out ? '\n\n' : ''}[mcp_servers.${NAME}]\ncommand = ${tomlString(entry.command)}\nargs = [${entry.args.map(tomlString).join(', ')}]`
-  }
-  return out ? out + '\n' : ''
-}
-
-// Write only when the content changes, keep one backup, and replace the file atomically.
-function rewrite(file, edit) {
-  const before = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : ''
-  const after = edit(before)
-  if (after === before) return 'unchanged'
-  if (before) fs.copyFileSync(file, `${file}.bak-dsh-baton`)
-  fs.mkdirSync(path.dirname(file), { recursive: true })
-  const tmp = `${file}.tmp-${process.pid}`
-  fs.writeFileSync(tmp, after, { mode: before ? fs.statSync(file).mode : 0o600 })
-  fs.renameSync(tmp, file)
-  return 'updated'
-}
+export { appDir, installApp, stableNodePath, claudeConfigPath, codexConfigPath, editClaudeConfig, editCodexConfig }
 
 function copyToClipboard(text) {
   try {
@@ -144,42 +90,12 @@ const PLUGIN = 'dsh-baton-host'
 
 const pluginFrom = (source, hostDir) => source === `link:${hostDir}` || source === `link:${hostDir.split(path.sep).join('/')}`
 
-// The node to register: the one on PATH when it is this same binary, since that path
-// survives upgrades (Homebrew's /opt/homebrew/bin/node, not the versioned Cellar path
-// that process.execPath resolves to); otherwise the running binary itself.
-export function stableNodePath(env = process.env, execPath = process.execPath) {
-  const real = (p) => { try { return fs.realpathSync(p) } catch { return null } }
-  const target = real(execPath)
-  const names = process.platform === 'win32' ? ['node.exe'] : ['node']
-  for (const dir of (env.PATH ?? env.Path ?? '').split(path.delimiter).filter(Boolean)) {
-    for (const name of names) {
-      const candidate = path.join(dir, name)
-      if (candidate !== execPath && target && real(candidate) === target) return candidate
-    }
-  }
-  return execPath
-}
-
 // Run through npx, the package sits in npm's cache, which npm may clear or replace at any
 // time. setup then copies it to a stable folder and registers that copy instead.
-export const appDir = () => path.join(config.batonHome, 'app')
 export const inNpxCache = (root = ROOT) => root.split(/[\\/]/).includes('_npx')
-const APP_PARTS = ['src', 'host', 'patches', 'package.json', 'LICENSE']
-
-export function installApp(from = ROOT, to = appDir()) {
-  fs.mkdirSync(to, { recursive: true })
-  for (const part of APP_PARTS) {
-    const src = path.join(from, part)
-    if (!fs.existsSync(src)) continue
-    // Replace each part whole, so files dropped in a newer version do not linger.
-    fs.rmSync(path.join(to, part), { recursive: true, force: true })
-    fs.cpSync(src, path.join(to, part), { recursive: true })
-  }
-  return to
-}
 
 export async function setup({ remove = false } = {}) {
-  const root = !remove && inNpxCache() ? installApp() : ROOT
+  const root = !remove && inNpxCache() ? installApp(ROOT) : ROOT
   const entry = remove ? null : { command: stableNodePath(), args: [path.join(root, 'src', 'server.mjs')] }
   const lines = []
   if (root !== ROOT) lines.push(`Installed dsh-baton to ${root}`)
@@ -187,7 +103,10 @@ export async function setup({ remove = false } = {}) {
     if (!remove && !present) return lines.push(`- ${label}: not installed, skipped`)
     try {
       const result = rewrite(file, (t) => edit(t, entry))
-      lines.push(`- ${label}: ${remove ? 'removed from' : 'registered in'} ${file}${result === 'unchanged' ? ' (already up to date)' : ''}`)
+      const what = remove
+        ? (result === 'unchanged' ? 'not registered in' : 'removed from')
+        : 'registered in'
+      lines.push(`- ${label}: ${what} ${file}${!remove && result === 'unchanged' ? ' (already up to date)' : ''}`)
     } catch (e) {
       lines.push(`- ${label}: FAILED to edit ${file}: ${e.message}`)
       process.exitCode = 1