dsh-plugin-mcp-toggles 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ZhaoHanshao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,111 @@
-# Temporary Holding Version
+# dsh-plugin-mcp-toggles
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/dsh-plugin-mcp-toggles.svg)](https://www.npmjs.com/package/dsh-plugin-mcp-toggles)
+[![license](https://img.shields.io/npm/l/dsh-plugin-mcp-toggles.svg)](LICENSE)
+[![node](https://img.shields.io/node/v/dsh-plugin-mcp-toggles.svg)](package.json)
+
+为**每个会话**单独开关已安装的 MCP 服务器。
+
+## 它解决什么
+
+MCP 服务器在 DSH profile 里是进程级的：`@deepseek-ai/dsh-mcp-client` 每行连一个
+服务器，把 `mcp__<serverName>__<tool>` 注册进**全局**工具层。于是每个会话都看到
+同一批 MCP 工具 —— 想让 A 会话只用 REA、B 会话只用别的服务器，原生做不到。
+
+装上本插件后：会话标题栏右侧出现一个 **MCP** 按钮，点开列出已安装的 MCP 服务器，
+每行一个开关，**只影响当前会话**。新会话默认全部开启（装上插件不会悄悄改变任何
+人现有的能力）。
+
+## 安装
+
+这是一个标准的 DSH bundle 包：`package.json` 里用 `dsh.bundle.patch` 声明要插入的
+插件行，用 `dsh.client` 声明 Web 端入口，没有依赖、没有构建步骤，装上即可用。
+
+从 npm 装进当前 profile：
+
+```
+plugin_manager action=install_bundle target=dsh-plugin-mcp-toggles
+```
+
+`target` 接受任意安装 spec：
+
+```
+plugin_manager action=install_bundle target=dsh-plugin-mcp-toggles@0.1.0
+plugin_manager action=install_bundle target=github:ZhaoHanshao/dsh-plugin-mcp-toggles
+```
+
+装好后重启 DSH，打开任意会话即可看到按钮。
+
+想先读代码或自己打包检查文件清单：
+
+```bash
+npm install dsh-plugin-mcp-toggles
+npm pack dsh-plugin-mcp-toggles --dry-run   # 只打印将要发布的文件
+```
+
+它需要宿主提供 `webServer` 服务与 `conversation.session.header.utilities` /
+`conversation.hero.options` 两个槽位，因此要求 DSH 版本不低于它开发时的
+`@deepseek-ai/dsh-client-ui-conversation`（运行时 **0.2.1-rc.3**）。这条约束写进了
+`peerDependencies`，但标记为可选 —— DSH 把这些包内置在自己的安装目录里，普通 npm
+安装不该为它再拉一份副本。
+
+Node 版本要求 `^22.19.0 || >=24.0.0`，与 DSH 官方下限一致。
+
+## 用法
+
+1. 打开任意会话 —— 或直接停在**新会话页**。
+2. 点标题栏（新会话页则是输入卡片上方那一行）的 **MCP** 按钮。
+3. 逐行开关，或点 `全部开启` / `全部关闭`。
+
+按钮上的徽标显示当前状态：`全部开启`、`n/m`、`全部关闭`；部分关闭时按钮转为警示色。
+
+## 两个入口，同一个开关集合
+
+| 槽位 | 出现位置 |
+|---|---|
+| `conversation.session.header.utilities` | 已有会话的标题栏右侧 |
+| `conversation.hero.options` | 新会话落地页，紧跟 workspace 与模式控件之后 |
+
+两处**必须都有**：新会话页的会话页头带 `hideChrome`
+（`blank && composerPhase === 'blank'`，见 `ConversationSession.tsx`），此时整个
+header 都不渲染，只挂标题栏会让按钮在新会话页上完全消失。两个槽都提供同一个
+`sessionId`，所以在哪一处切换都是同一个会话的开关 —— 在新会话页关掉的服务器，
+进入对话后依然关着。
+
+## 它怎么工作
+
+`agent.ctx.tools.restrict({ deny })` 是**作用域内**生效的全局工具掩码
+（`packages/core/tools/src/index.ts`）。可见性、schema 投影与派发都走同一个解析器，
+因此被关掉的工具模型既看不到也调不到，其他会话不受影响。
+
+- 关闭某服务器 → 把它的 `mcp__<server>__*` 工具加进该会话的 deny 集。
+- 全部服务器都关闭时，共享的 `list_mcp_resources` 等资源工具一并隐藏
+  （`sharedResourceTools: false` 可关掉这个联动）。
+- 开关立即生效，无需重启会话或重开服务器。
+
+## 开关存在哪
+
+`$DSH_HOME/mcp-toggles-state.json`：
+
+```json
+{ "bySession": { "<sessionId>": { "rea": false } } }
+```
+
+键是 sessionId。**没有记录即视为开启** —— 只会记录「关掉」，所以新会话、以及删掉
+状态文件之后的会话，都回到全部开启。
+
+## 配置
+
+`cordis.patch.yml` 的行配置：
+
+| 字段 | 默认 | 含义 |
+|---|---|---|
+| `sharedResourceTools` | `true` | 关闭全部 MCP 时是否连共享资源工具一起隐藏。 |
+| `extraServers` | `[]` | 额外要认作 MCP 服务器的名字；用于服务器暂时没有注册任何工具时也能列出来。 |
+
+## 已知限制
+
+- 只管理 **MCP** 工具（`mcp__*` 前缀与共享资源工具），不动其他工具。
+- 服务器列表来自 `configEditor.entries()` 里的 `@deepseek-ai/dsh-mcp-client` 行；
+  `configEditor` 不可用时退回当前工具名前缀，此时**没有工具**的服务器不会出现在列表里。
+- 开关按会话 id 保存；会话被删除后对应记录会保留（无害，不会影响其他会话）。

package/cordis.patch.yml

@@ -0,0 +1,5 @@
+- insert:
+    - id: mcp-toggles
+      name: 'dsh-plugin-mcp-toggles'
+      config:
+        sharedResourceTools: true

package/icon.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" fill="none">
+  <path d="M8.5 2.5v4.2M15.5 2.5v4.2" stroke="#1f2933" stroke-width="1.6" stroke-linecap="round"/>
+  <path d="M5.6 6.7h12.8v3.6a6.4 6.4 0 0 1-12.8 0V6.7Z" stroke="#1f2933" stroke-width="1.6" stroke-linejoin="round"/>
+  <path d="M12 16.7V21" stroke="#1f2933" stroke-width="1.6" stroke-linecap="round"/>
+  <circle cx="19" cy="18.5" r="4.1" fill="#247bbf"/>
+  <path d="M16.9 18.5h4.2" stroke="#fff" stroke-width="1.5" stroke-linecap="round"/>
+</svg>

package/lib/client.js

@@ -0,0 +1,473 @@
+/**
+ * dsh-plugin-mcp-toggles — 客户端半。
+ *
+ * 在**会话标题栏**放一个 MCP 选择按钮：点开后列出已安装的 MCP 服务器，
+ * 每行一个开关，只作用于当前会话。不占侧栏入口，也没有独立页面 ——
+ * 开关就发生在会话本身里。
+ *
+ * 模块自包含：只依赖平台种子 `react`。
+ */
+
+window.__ModuleLoader__.load({
+  id: 'dsh-plugin-mcp-toggles',
+  factory: (require) => {
+    const React = require('react')
+
+    const NS = 'mcp-toggles'
+    const API = '/mcp-toggles/api'
+    const TOKEN_META = 'dsh-mcp-toggles'
+
+    // #region 文案
+
+    const zh = {
+      'picker.title': '选择本会话可用的 MCP 服务器',
+      'picker.loading': '读取中…',
+      'picker.empty': '没有已安装的 MCP 服务器',
+      'picker.emptyHint': '在 设置 → 插件 里安装一个 MCP 服务器后，它会出现在这里。',
+      'picker.failed': '读取失败',
+      'picker.retry': '重试',
+      'picker.scope': '仅本会话生效',
+      'picker.scopeDefault': '将用于之后新建的会话',
+      'picker.allOn': '全部开启',
+      'picker.allOff': '全部关闭',
+      'picker.on': '开',
+      'picker.off': '关',
+      'picker.disconnected': '未连接',
+      'picker.tools': '个工具',
+      'picker.shadowed': '本会话隐藏',
+      'picker.summary.all': '全部开启',
+      'picker.summary.none': '全部关闭',
+      'picker.summary.pending': '选择 MCP',
+      'picker.saving': '保存中…',
+      'picker.unsaved': '未写入磁盘',
+    }
+
+    const en = {
+      'picker.title': 'Choose the MCP servers this conversation can use',
+      'picker.loading': 'Loading…',
+      'picker.empty': 'No MCP server is installed',
+      'picker.emptyHint': 'Install an MCP server under Settings → Plugins and it shows up here.',
+      'picker.failed': 'Load failed',
+      'picker.retry': 'Retry',
+      'picker.scope': 'Applies to this conversation only',
+      'picker.scopeDefault': 'Applies to conversations you start from here',
+      'picker.allOn': 'Turn all on',
+      'picker.allOff': 'Turn all off',
+      'picker.on': 'On',
+      'picker.off': 'Off',
+      'picker.disconnected': 'not connected',
+      'picker.tools': 'tools',
+      'picker.shadowed': 'hidden here',
+      'picker.summary.all': 'All on',
+      'picker.summary.none': 'All off',
+      'picker.summary.pending': 'MCP',
+      'picker.saving': 'Saving…',
+      'picker.unsaved': 'not written to disk',
+    }
+
+    // #endregion
+
+    // #region 令牌与请求
+
+    let cachedToken
+
+    /** 从页面 meta 读令牌；插件晚于页面加载时退回路由获取。 */
+    async function token() {
+      if (cachedToken !== undefined) return cachedToken
+      const meta = document.querySelector(`meta[name="${TOKEN_META}"]`)
+      if (meta !== null) {
+        const value = meta.getAttribute('content')
+        if (value !== null && value.length > 0) {
+          cachedToken = value
+          return cachedToken
+        }
+      }
+      const response = await fetch(`${API}/token`, { credentials: 'same-origin' })
+      if (!response.ok) throw new Error(`token ${response.status}`)
+      cachedToken = (await response.json()).token
+      return cachedToken
+    }
+
+    /** 统一请求；非 2xx 抛错并带上服务端消息。 */
+    async function api(path, options = {}) {
+      const headers = { 'x-mcp-toggles-token': await token() }
+      if (options.payload !== undefined) headers['content-type'] = 'application/json'
+      const response = await fetch(`${API}${path}`, {
+        method: options.method ?? 'GET',
+        headers,
+        credentials: 'same-origin',
+        signal: options.signal,
+        ...options.payload === undefined ? {} : { body: JSON.stringify(options.payload) },
+      })
+      const payload = await response.json().catch(() => ({}))
+      if (!response.ok) throw new Error(payload?.error?.message ?? `HTTP ${response.status}`)
+      return payload
+    }
+
+    // #endregion
+
+    // #region 图标
+
+    /** 插头图标：一眼看出这是「连接」类开关。 */
+    function PlugGlyph({ size = 15 }) {
+      return React.createElement('svg', {
+        width: size, height: size, viewBox: '0 0 24 24', fill: 'none', 'aria-hidden': true,
+      },
+      React.createElement('path', {
+        d: 'M9 3v5M15 3v5',
+        stroke: 'currentColor', strokeWidth: 1.8, strokeLinecap: 'round',
+      }),
+      React.createElement('path', {
+        d: 'M6.5 8h11v3.2a5.5 5.5 0 0 1-11 0V8Z',
+        stroke: 'currentColor', strokeWidth: 1.8, strokeLinejoin: 'round',
+      }),
+      React.createElement('path', {
+        d: 'M12 16.7V21',
+        stroke: 'currentColor', strokeWidth: 1.8, strokeLinecap: 'round',
+      }))
+    }
+
+    /** 小箭头。 */
+    function Caret() {
+      return React.createElement('svg', {
+        width: 10, height: 10, viewBox: '0 0 24 24', fill: 'none', 'aria-hidden': true,
+      }, React.createElement('path', {
+        d: 'm6 9 6 6 6-6',
+        stroke: 'currentColor', strokeWidth: 2.2, strokeLinecap: 'round', strokeLinejoin: 'round',
+      }))
+    }
+
+    // #endregion
+
+    // 与同区域的系统按钮（open-in-app / agent-terminal / schedule-catalog）保持
+    // 同一套尺寸：高 24px、字号 11px、0.5px 边框、--dsw-radius-sm。
+    const STYLE = `
+.mt-wrap { position: relative; display: inline-flex; flex: none; align-self: center; }
+.mt-trigger {
+  box-sizing: border-box; display: inline-flex; align-items: center; gap: 4px;
+  height: 24px; padding: 3px 6px; max-width: 190px;
+  border: .5px solid var(--dsw-alias-border-l4); border-radius: var(--dsw-radius-sm);
+  background: 0 0; color: var(--dsw-alias-label-primary);
+  font-family: var(--dsw-font-family); font-size: 11px; line-height: 16px;
+  white-space: nowrap; cursor: pointer;
+}
+.mt-trigger:hover { background: var(--dsw-alias-interactive-bg-hover); }
+.mt-trigger:focus-visible { background: var(--dsw-alias-interactive-bg-hover); outline: none; }
+.mt-trigger[data-open="true"] { border-color: var(--dsw-alias-border-l2); background: var(--dsw-alias-interactive-bg-hover); }
+.mt-trigger[data-partial="true"] { color: var(--dsw-alias-state-warn-primary); }
+.mt-trigger[data-none="true"] { color: var(--dsw-alias-label-secondary); }
+/* 新会话落地页那一行比标题栏更矮更紧凑，和相邻的 workspace／preset 控件同高。 */
+.mt-trigger[data-compact="true"] { height: 22px; padding: 2px 6px; font-size: 10.5px; }
+.mt-link[data-disabled="true"] { opacity: .5; cursor: default; pointer-events: none; }
+.mt-icon { flex: none; display: inline-flex; align-items: center; opacity: .9; }
+.mt-name { overflow: hidden; text-overflow: ellipsis; }
+.mt-caret { flex: none; display: inline-flex; align-items: center; color: var(--dsw-alias-label-secondary); transition: transform .12s ease; }
+.mt-trigger[data-open="true"] .mt-caret { transform: rotate(180deg); }
+.mt-menu {
+  position: absolute; top: calc(100% + 5px); right: 0; z-index: 60;
+  width: 330px; max-height: 60vh; overflow-y: auto; padding: 4px;
+  border: .5px solid var(--dsw-alias-border-l2); border-radius: var(--dsw-radius-md);
+  background: var(--dsw-alias-bg-overlay); box-shadow: 0 8px 24px rgba(0,0,0,.16);
+}
+.mt-head {
+  display: flex; align-items: center; justify-content: space-between; gap: 8px;
+  padding: 5px 8px 6px; font-size: 11px; line-height: 16px;
+  color: var(--dsw-alias-label-secondary);
+}
+.mt-headActions { display: inline-flex; align-items: center; gap: 8px; flex: none; }
+.mt-link { cursor: pointer; color: var(--dsw-alias-label-secondary); }
+.mt-link:hover { color: var(--dsw-alias-brand-primary); }
+.mt-item {
+  display: flex; align-items: center; gap: 8px; padding: 6px 8px;
+  border-radius: var(--dsw-radius-sm); cursor: pointer;
+}
+.mt-item:hover { background: var(--dsw-alias-interactive-bg-hover); }
+.mt-item[data-busy="true"] { opacity: .6; cursor: default; }
+.mt-body { flex: 1; min-width: 0; }
+.mt-title { display: flex; align-items: center; gap: 5px; font-size: 11px; line-height: 16px; color: var(--dsw-alias-label-primary); }
+.mt-sub {
+  margin-top: 1px; font-size: 10px; line-height: 14px;
+  color: var(--dsw-alias-label-secondary);
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+}
+.mt-badge {
+  flex: none; padding: 0 4px; border-radius: var(--dsw-radius-xs);
+  font-size: 9.5px; line-height: 14px;
+  background: var(--dsw-alias-bg-layer-2); color: var(--dsw-alias-label-secondary);
+}
+.mt-badge[data-tone="warn"] { color: var(--dsw-alias-state-warn-primary); }
+.mt-switch {
+  flex: none; position: relative; box-sizing: border-box;
+  width: 26px; height: 15px; padding: 0; border-radius: 999px;
+  border: .5px solid var(--dsw-alias-border-l2);
+  background: var(--dsw-alias-bg-layer-2); cursor: pointer; transition: background .12s ease;
+}
+.mt-switch::after {
+  content: ""; position: absolute; top: 1.5px; left: 2px;
+  width: 10px; height: 10px; border-radius: 50%;
+  background: var(--dsw-alias-label-secondary); transition: transform .12s ease, background .12s ease;
+}
+.mt-switch[aria-checked="true"] { background: var(--dsw-alias-brand-primary); border-color: var(--dsw-alias-brand-primary); }
+.mt-switch[aria-checked="true"]::after { transform: translateX(11px); background: var(--dsw-alias-bg-base); }
+.mt-switch:focus-visible { outline: 2px solid var(--dsw-alias-brand-primary); outline-offset: 1px; }
+.mt-switch:disabled { opacity: .5; cursor: default; }
+.mt-sep { height: .5px; margin: 4px 2px; background: var(--dsw-alias-border-l1); }
+.mt-foot {
+  display: flex; align-items: center; gap: 6px; padding: 5px 8px;
+  font-size: 10.5px; line-height: 15px; color: var(--dsw-alias-label-secondary);
+}
+.mt-err { padding: 3px 8px 6px; font-size: 10.5px; line-height: 15px; color: var(--dsw-alias-state-error-primary); }
+.mt-btn {
+  padding: 3px 8px; border: .5px solid var(--dsw-alias-border-l2); border-radius: var(--dsw-radius-sm);
+  background: 0 0; color: var(--dsw-alias-label-primary);
+  font-family: var(--dsw-font-family); font-size: 11px; line-height: 16px; cursor: pointer;
+}
+.mt-btn:hover { background: var(--dsw-alias-interactive-bg-hover); }
+.mt-btn:disabled { opacity: .5; cursor: default; }
+`
+
+    // #region 选择器
+
+    /**
+     * MCP 开关选择器。
+     *
+     * 同一个组件用于两处：
+     *   - `conversation.session.header.utilities`（有会话时的标题栏工具区）；
+     *   - `conversation.hero.options`（新会话落地页那一行）。
+     *
+     * 后者是必需的：新会话页的会话页头带 `hideChrome`，整个 header 都不渲染，
+     * 只挂标题栏会让按钮在新会话页上消失。两处都由槽提供 `sessionId`，因此
+     * 开关始终绑定在同一个会话上 —— 在新会话页关掉的服务器，进入对话后依然关着。
+     * @param props 会话标准 props、`t`，以及可选的 `compact`。
+     */
+    function McpPicker({ sessionId, t, compact }) {
+      const [open, setOpen] = React.useState(false)
+      const [state, setState] = React.useState({ phase: 'loading' })
+      const [attempt, setAttempt] = React.useState(0)
+      const [busy, setBusy] = React.useState(false)
+      const [error, setError] = React.useState()
+      const [notice, setNotice] = React.useState()
+      const rootRef = React.useRef(null)
+
+      // 开关按会话 id 保存；槽还没给出会话时没有可写的键。
+      const scoped = sessionId !== undefined && sessionId !== null && String(sessionId) !== ''
+      const sessionKey = scoped ? String(sessionId) : ''
+
+      // 读当前会话的开关快照：首次渲染与每次重试都读。
+      React.useEffect(() => {
+        if (!scoped) return undefined
+        const controller = new AbortController()
+        api(`/state?session=${encodeURIComponent(sessionKey)}`, { signal: controller.signal })
+          .then((payload) => {
+            if (controller.signal.aborted) return
+            setState({ phase: 'ready', data: payload })
+          }, (reason) => {
+            if (controller.signal.aborted) return
+            setState({ phase: 'failed', message: reason instanceof Error ? reason.message : String(reason) })
+          })
+        return () => { controller.abort() }
+      }, [scoped, sessionKey, attempt])
+
+      // 工具集合可能在本插件之外变化（服务器重连）；打开时刷新一次。
+      React.useEffect(() => {
+        if (!open || !scoped) return undefined
+        const controller = new AbortController()
+        api(`/state?session=${encodeURIComponent(sessionKey)}`, { signal: controller.signal })
+          .then((payload) => {
+            if (controller.signal.aborted) return
+            setState({ phase: 'ready', data: payload })
+          }, () => {})
+        return () => { controller.abort() }
+      }, [open, scoped, sessionKey])
+
+      // 点击外部或 Esc 关闭。
+      React.useEffect(() => {
+        if (!open) return undefined
+        const onPointerDown = (event) => {
+          if (rootRef.current !== null && !rootRef.current.contains(event.target)) setOpen(false)
+        }
+        const onKeyDown = (event) => {
+          if (event.key === 'Escape') setOpen(false)
+        }
+        document.addEventListener('pointerdown', onPointerDown)
+        document.addEventListener('keydown', onKeyDown)
+        return () => {
+          document.removeEventListener('pointerdown', onPointerDown)
+          document.removeEventListener('keydown', onKeyDown)
+        }
+      }, [open])
+
+      const data = state.phase === 'ready' ? state.data : undefined
+      const servers = data?.servers ?? []
+      const enabledCount = data?.enabledCount ?? 0
+
+      const label = !scoped
+        ? t('picker.summary.pending')
+        : data === undefined
+          ? t('picker.loading')
+          : servers.length === 0
+            ? t('picker.empty')
+            : enabledCount === servers.length
+              ? t('picker.summary.all')
+              : enabledCount === 0
+                ? t('picker.summary.none')
+                : `${enabledCount}/${servers.length}`
+
+      const tone = servers.length > 0 && enabledCount === 0
+        ? 'none'
+        : servers.length > 0 && enabledCount < servers.length ? 'partial' : 'all'
+
+      /** 写入一个开关（`server` 省略表示整组）。 */
+      const toggle = async (server, enabled) => {
+        if (!scoped) return
+        setBusy(true)
+        setError(undefined)
+        setNotice(undefined)
+        try {
+          const payload = await api('/toggle', {
+            method: 'POST',
+            payload: { session: sessionKey, server, enabled },
+          })
+          setState({ phase: 'ready', data: payload })
+          if (payload.persisted === false) setNotice(t('picker.unsaved'))
+        } catch (reason) {
+          setError(reason instanceof Error ? reason.message : String(reason))
+        } finally {
+          setBusy(false)
+        }
+      }
+
+      /** 渲染一个服务器行。 */
+      const renderRow = (server) => {
+        const on = server.enabled === true
+        return React.createElement('div', {
+          key: server.name,
+          className: 'mt-item',
+          'data-busy': String(busy),
+        },
+        React.createElement('div', { className: 'mt-body' },
+          React.createElement('div', { className: 'mt-title' },
+            server.name,
+            server.connected !== true && React.createElement('span', {
+              className: 'mt-badge', 'data-tone': 'warn',
+            }, t('picker.disconnected'))),
+          React.createElement('div', { className: 'mt-sub', title: server.target },
+            `${server.tools} ${t('picker.tools')}${server.target === '' ? '' : ` · ${server.target}`}`)),
+        React.createElement('button', {
+          type: 'button',
+          className: 'mt-switch',
+          role: 'switch',
+          'aria-checked': on,
+          'aria-label': server.name,
+          disabled: busy,
+          onClick: () => { void toggle(server.name, !on) },
+        }))
+      }
+
+      return React.createElement('div', { className: 'mt-wrap', ref: rootRef },
+        React.createElement('style', null, STYLE),
+        React.createElement('button', {
+          type: 'button',
+          className: 'mt-trigger',
+          'data-open': String(open),
+          'data-partial': String(tone === 'partial'),
+          'data-none': String(tone === 'none'),
+          'data-compact': String(compact === true),
+          title: `${t('picker.title')} — ${label}`,
+          'aria-haspopup': 'dialog',
+          'aria-expanded': open,
+          onClick: () => { setOpen((value) => !value) },
+        },
+        React.createElement('span', { className: 'mt-icon' }, React.createElement(PlugGlyph, { size: 13 })),
+        React.createElement('span', { className: 'mt-name' }, 'MCP'),
+        React.createElement('span', {
+          className: 'mt-badge',
+          'data-tone': tone === 'none' ? 'warn' : undefined,
+        }, label),
+        React.createElement('span', { className: 'mt-caret' }, React.createElement(Caret))),
+
+        open && React.createElement('div', {
+          className: 'mt-menu',
+          role: 'dialog',
+          'aria-label': t('picker.title'),
+        },
+        React.createElement('div', { className: 'mt-head' },
+          React.createElement('span', null, scoped ? t('picker.scope') : t('picker.scopeDefault')),
+          React.createElement('span', { className: 'mt-headActions' },
+            React.createElement('span', {
+              className: 'mt-link',
+              role: 'button',
+              tabIndex: 0,
+              'data-disabled': String(!scoped || busy),
+              onClick: () => { if (scoped && !busy) void toggle(null, true) },
+              onKeyDown: (event) => {
+                if (event.key === 'Enter' && scoped && !busy) void toggle(null, true)
+              },
+            }, t('picker.allOn')),
+            React.createElement('span', {
+              className: 'mt-link',
+              role: 'button',
+              tabIndex: 0,
+              'data-disabled': String(!scoped || busy),
+              onClick: () => { if (scoped && !busy) void toggle(null, false) },
+              onKeyDown: (event) => {
+                if (event.key === 'Enter' && scoped && !busy) void toggle(null, false)
+              },
+            }, t('picker.allOff')))),
+
+        !scoped && React.createElement('div', { className: 'mt-foot' }, t('picker.scopeDefault')),
+        scoped && state.phase === 'loading'
+          && React.createElement('div', { className: 'mt-foot' }, t('picker.loading')),
+        state.phase === 'failed' && React.createElement('div', { className: 'mt-err' },
+          `${t('picker.failed')}: ${state.message}`,
+          React.createElement('button', {
+            type: 'button',
+            className: 'mt-btn',
+            style: { marginLeft: 8 },
+            onClick: () => {
+              setState({ phase: 'loading' })
+              setAttempt((value) => value + 1)
+            },
+          }, t('picker.retry'))),
+
+        data !== undefined && servers.length === 0 && React.createElement('div', { className: 'mt-foot' },
+          t('picker.emptyHint')),
+
+        servers.map(renderRow),
+
+        error !== undefined && React.createElement('div', { className: 'mt-err' }, error),
+        notice !== undefined && React.createElement('div', { className: 'mt-foot' }, notice),
+        busy && React.createElement('div', { className: 'mt-foot' }, t('picker.saving'))))
+    }
+
+    // #endregion
+
+    // #region 插件
+
+    return {
+      inject: ['slots', 'locale'],
+      apply(ctx) {
+        ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'mcp-toggles: dictionaries')
+
+        // 会话标题栏右侧工具区：选择器天然绑定当前会话。
+        ctx.effect(() => ctx.slots.inject('conversation.session.header.utilities', () => ctx.slots.register({
+          name: 'conversation.session.header.utilities',
+          id: 'mcp-toggles',
+          order: -7,
+          locale: NS,
+        }, McpPicker)), 'mcp-toggles: header picker')
+
+        // 新会话落地页那一行。必需：该页的会话页头整体带 `hideChrome`
+        // （`blank && composerPhase === 'blank'`），只挂标题栏会让按钮在
+        // 新会话页上完全消失。
+        ctx.effect(() => ctx.slots.inject('conversation.hero.options', () => ctx.slots.register({
+          name: 'conversation.hero.options',
+          id: 'mcp-toggles-hero',
+          order: 20,
+          locale: NS,
+        }, (props) => React.createElement(McpPicker, { ...props, compact: true }))),
+        'mcp-toggles: hero picker')
+      },
+    }
+  },
+})

package/lib/index.js

@@ -0,0 +1,560 @@
+/**
+ * dsh-plugin-mcp-toggles — 让每个会话单独决定哪些 MCP 服务器对模型可见。
+ *
+ * ## 为什么需要它
+ * MCP 服务器在 profile 里是**进程级**的：`@deepseek-ai/dsh-mcp-client` 每行
+ * 连一个服务器，并把 `mcp__<serverName>__<tool>` 注册到**全局**工具层。于是
+ * 每个会话都看得到同一批 MCP 工具 —— 想在一个会话里只用 REA、在另一个会话
+ * 里只用别的服务器，原生做不到。
+ *
+ * ## 实际使用的机制
+ * `agent.ctx.tools.restrict({ deny })` 是作用域内生效的**全局工具掩码**
+ * （见 `packages/core/tools/src/index.ts` 的 `restrict`）：只影响该 agent
+ * 的可见工具集，schema 投影、查找与派发都走同一个解析器，因此模型既看不到
+ * 也调不到被关掉的工具，而其他会话完全不受影响。
+ *
+ * 每个会话的开关存在 `$DSH_HOME/mcp-toggles-state.json`：键是 sessionId，
+ * 值是 `{ [serverName]: boolean }`。未记录即视为开启 —— 装上插件不会悄悄
+ * 关掉任何人的 MCP。
+ *
+ * @module dsh-plugin-mcp-toggles
+ */
+
+import { randomBytes } from 'node:crypto'
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+export const name = 'mcp-toggles'
+export const inject = ['webServer']
+
+// #region 常量
+
+/** API 前缀（与客户端半的常量保持一致）。 */
+const API_PREFIX = '/mcp-toggles/api'
+
+/** 页面 meta 名：客户端据此拿到同源令牌。 */
+const TOKEN_META_NAME = 'dsh-mcp-toggles'
+
+/** 请求头名。 */
+const TOKEN_HEADER = 'x-mcp-toggles-token'
+
+/** 请求体上限。 */
+const MAX_BODY_BYTES = 32 * 1024
+
+/** mcp-client 的包名：`configEditor.entries()` 里它就是 MCP 行。 */
+const MCP_CLIENT_PACKAGE = '@deepseek-ai/dsh-mcp-client'
+
+/** 由 `@deepseek-ai/dsh-mcp-resources` 注册的共享资源工具。 */
+const SHARED_RESOURCE_TOOLS = ['list_mcp_resources', 'list_mcp_resource_templates', 'read_mcp_resource']
+
+/** 工具名前缀 / 分隔：`mcp__<serverName>__<rawName>`。 */
+const PUBLIC_PREFIX = 'mcp__'
+
+/** 从 `mcp__<server>__<tool>` 里取回服务器名的兜底解析。 */
+const FALLBACK_PARSE = /^mcp__(.+?)__(.+)$/
+
+/**
+ * 进程级掩码登记表的键。
+ *
+ * Hot reload 会重新求值本模块，模块级的 Map 随之丢掉，而 `restrict()` 装下的
+ * 掩码属于 agent 作用域、并不随模块销毁 —— 旧 disposer 一旦丢失，那层掩码就
+ * 永久生效，表现为「某些会话突然看不到 MCP 工具且开关无效」。因此登记表放在
+ * 全局，新模块直接接手上一代留下的记录并可以正常撤销。
+ */
+const MASKS_KEY = Symbol.for('dsh-plugin-mcp-toggles.masks')
+
+// #endregion
+
+// #region 配置
+
+/**
+ * 解析插件配置。
+ * @param config 来自 `cordis.patch.yml` 的原始配置。
+ * @returns 归一化后的配置。
+ */
+export function resolveConfig(config = {}) {
+  return {
+    /**
+     * 共享的 MCP 资源工具（`list_mcp_resources` 等）是否跟随整体开关：
+     * 只有当前会话关掉了**全部** MCP 服务器时才隐藏它们。
+     */
+    sharedResourceTools: config.sharedResourceTools !== false,
+    /** 额外需要识别为 MCP 服务器的名字（服务器暂时没有工具时也能列出）。 */
+    extraServers: Array.isArray(config.extraServers)
+      ? config.extraServers.filter((name) => typeof name === 'string' && name.length > 0)
+      : [],
+  }
+}
+
+// #endregion
+
+// #region 选择存储
+
+/** 状态文件。 */
+function stateFile() {
+  const home = process.env.DSH_HOME ?? join(homedir(), '.dsh')
+  return join(home, 'mcp-toggles-state.json')
+}
+
+/** 读取持久化的每会话开关；坏文件退回空状态，不影响使用。 */
+function loadState() {
+  try {
+    const parsed = JSON.parse(readFileSync(stateFile(), 'utf8'))
+    const bySession = parsed?.bySession
+    if (typeof bySession !== 'object' || bySession === null) return { bySession: {} }
+    /** @type {Record<string, Record<string, boolean>>} */
+    const clean = {}
+    for (const [sessionId, entry] of Object.entries(bySession)) {
+      if (typeof entry !== 'object' || entry === null) continue
+      const row = {}
+      for (const [server, enabled] of Object.entries(entry)) {
+        if (typeof enabled === 'boolean') row[server] = enabled
+      }
+      clean[sessionId] = row
+    }
+    return { bySession: clean }
+  } catch {
+    return { bySession: {} }
+  }
+}
+
+/** 写回持久化开关；失败只影响下次启动，不影响本次运行。 */
+function saveState(state) {
+  try {
+    mkdirSync(dirname(stateFile()), { recursive: true })
+    writeFileSync(stateFile(), JSON.stringify(state, null, 2), 'utf8')
+    return true
+  } catch {
+    return false
+  }
+}
+
+// #endregion
+
+// #region 插件
+
+/**
+ * 注册路由，并按会话装配 MCP 工具掩码。
+ * @param ctx 插件上下文。
+ * @param rawConfig 行配置。
+ */
+export function apply(ctx, rawConfig = {}) {
+  const config = resolveConfig(rawConfig)
+  const log = ctx.logger?.('mcp-toggles') ?? console
+  // 每次加载生成一枚随机令牌，注入页面 meta，客户端回传它才允许改开关。
+  // 用加密随机源而非 Math.random：这枚令牌是唯一挡住跨站改写的东西。
+  const token = randomBytes(32).toString('hex')
+  const state = loadState()
+
+  /**
+   * 每个会话当前已装的掩码：`key` 是生效的 deny 指纹，用于幂等判断
+   * （`restrict` 会触发 `tools/change`，指纹相同就不再重装，避免自激）。
+   *
+   * 跨模块代际共享（见 {@link MASKS_KEY}）：热重载后新模块接手旧记录，也就能
+   * 撤销旧一代装下的掩码，不会留下永久生效的孤儿。
+   * @type {Map<string, { key: string, dispose?: () => void }>}
+   */
+  const installed = globalThis[MASKS_KEY] ??= new Map()
+
+  /**
+   * 本代模块的身份。
+   *
+   * 插件热重载会先卸载旧一代：旧一代的 `ctx.effect` 随插件上下文销毁，掩码
+   * 已经撤销，但共享登记表里还留着旧记录。只比 deny 指纹会把这种**已失效**的
+   * 记录误当成现役状态，于是新会话看不到应有的工具掩码。因此记录带上代际，
+   * 只有本代亲手装的记录才算现役。
+   */
+  const generation = Symbol('mcp-toggles generation')
+
+  /** 本代模块亲手装过的会话；卸载时只清理这些，不误伤下一代接手的记录。 */
+  const mine = new Set()
+
+  // #region 服务器目录
+
+  /**
+   * 读 `configEditor` 里所有 MCP 行，拿到 serverName 与连接参数事实。
+   *
+   * 这一步只用于**列出**：即使某个服务器当前一个工具都没连上，用户也能在
+   * 选择器里看到它并预先关掉。`configEditor` 缺失或被禁用时返回空数组。
+   * @returns serverName → 行事实。
+   */
+  const configuredServers = () => {
+    /** @type {Map<string, { name: string, transport: string, target: string, rowId: string }>} */
+    const found = new Map()
+    try {
+      const editor = ctx.get('configEditor')
+      if (editor === undefined) return found
+      for (const entry of editor.entries()) {
+        if (entry?.options?.name !== MCP_CLIENT_PACKAGE) continue
+        const raw = entry.options.config
+        if (typeof raw !== 'object' || raw === null) continue
+        const serverName = typeof raw.serverName === 'string' ? raw.serverName : undefined
+        if (serverName === undefined || serverName.length === 0) continue
+        found.set(serverName, {
+          name: serverName,
+          transport: typeof raw.transport === 'string' ? raw.transport : 'stdio',
+          target: typeof raw.url === 'string'
+            ? raw.url
+            : typeof raw.command === 'string' ? raw.command : '',
+          rowId: typeof entry.options.id === 'string' ? entry.options.id : '',
+        })
+      }
+    } catch (error) {
+      // configEditor 可能因 profile 只读或版本差异不可用；列不出服务器并不
+      // 妨碍已连接服务器的开关，所以这里只记录一次。
+      log?.debug?.(`mcp-toggles: configEditor unavailable: ${String(error?.message ?? error)}`)
+    }
+    for (const serverName of config.extraServers) {
+      if (found.has(serverName)) continue
+      found.set(serverName, { name: serverName, transport: 'unknown', target: '', rowId: '' })
+    }
+    return found
+  }
+
+  /**
+   * 从全局工具视图里按服务器归组 MCP 工具。
+   *
+   * 优先用 `configEditor` 给的名字做前缀匹配（服务器名本身可能含 `__`），
+   * 再用 `mcp__<server>__<tool>` 兜底解析没匹配上的名字。
+   * @returns serverName → 公开工具名列表。
+   */
+  const toolsByServer = () => {
+    /** @type {Map<string, string[]>} */
+    const grouped = new Map()
+    const tools = ctx.get('tools')
+    if (tools === undefined) return grouped
+    let names = []
+    try {
+      names = tools.schemas().map((schema) => schema.name)
+    } catch (error) {
+      log?.warn?.(`mcp-toggles: cannot read global tool schemas: ${String(error?.message ?? error)}`)
+      return grouped
+    }
+    const known = [...configuredServers().keys()].sort((left, right) => right.length - left.length)
+    const push = (server, toolName) => {
+      const list = grouped.get(server)
+      if (list === undefined) grouped.set(server, [toolName])
+      else list.push(toolName)
+    }
+    for (const toolName of names) {
+      if (!toolName.startsWith(PUBLIC_PREFIX)) continue
+      const matched = known.find((server) => toolName.startsWith(`${PUBLIC_PREFIX}${server}__`))
+      if (matched !== undefined) {
+        push(matched, toolName)
+        continue
+      }
+      const parsed = FALLBACK_PARSE.exec(toolName)
+      if (parsed !== null) push(parsed[1], toolName)
+    }
+    for (const list of grouped.values()) list.sort()
+    return grouped
+  }
+
+  /**
+   * 当前进程里可开关的 MCP 服务器：已配置的行 ∪ 当前有工具的服务器。
+   * @returns 按名字排序的服务器目录。
+   */
+  const serverCatalog = () => {
+    const configured = configuredServers()
+    const grouped = toolsByServer()
+    const names = new Set([...configured.keys(), ...grouped.keys()])
+    return [...names].sort((left, right) => left.localeCompare(right)).map((serverName) => {
+      const row = configured.get(serverName)
+      return {
+        name: serverName,
+        transport: row?.transport ?? 'unknown',
+        target: row?.target ?? '',
+        tools: grouped.get(serverName) ?? [],
+        connected: grouped.has(serverName),
+      }
+    })
+  }
+
+  // #endregion
+
+  // #region 开关与掩码
+
+  /**
+   * 某会话里某个服务器是否开启；没有显式记录即视为开启。
+   * @param sessionId 会话 id。
+   * @param serverName 服务器名。
+   * @returns 是否对该会话可见。
+   */
+  const isEnabled = (sessionId, serverName) => state.bySession[sessionId]?.[serverName] !== false
+
+  /**
+   * 计算某会话应当被 deny 的全局工具名。
+   * @param sessionId 会话 id。
+   * @param catalog 一次性读到的服务器目录。
+   * @returns 排序后的工具名列表。
+   */
+  const denyFor = (sessionId, catalog) => {
+    const deny = []
+    for (const server of catalog) {
+      if (isEnabled(sessionId, server.name)) continue
+      deny.push(...server.tools)
+    }
+    if (config.sharedResourceTools && catalog.length > 0
+      && catalog.every(server => !isEnabled(sessionId, server.name))) {
+      deny.push(...SHARED_RESOURCE_TOOLS)
+    }
+    return deny.sort()
+  }
+
+  /** 撤掉某会话已装的掩码。 */
+  const clearSession = (sessionId) => {
+    const previous = installed.get(sessionId)
+    if (previous === undefined) return
+    installed.delete(sessionId)
+    try { previous.dispose?.() } catch {}
+  }
+
+  /**
+   * 为一个会话重算并装上掩码。**只在 {@link reconcile} 内部调用。**
+   *
+   * `restrict()` 与它返回的 disposer 都会**同步**发出 `tools/change`；若允许
+   * 在这两次调用之间重入，就会装出第二层掩码，随后被覆盖的记录再也撤销不掉
+   * —— 表现为「关掉能生效、再打开不生效」。{@link reconcile} 用一次性重试把
+   * 这种同步重入折叠成收尾的一轮，这里因此可以按「先摘旧、再装新」的直线顺序写。
+   *
+   * 掩码注册在 `agent.ctx` 上（`restrict` 只接受作用域上下文），但登记**持有者**
+   * 是本插件的 `ctx.effect`：作用域上下文与插件上下文都会在销毁时调用同一个
+   * disposer，因此插件热重载或会话销毁都不会留下抹不掉的掩码。
+   * @param agent 目标 agent。
+   * @param catalog 复用的服务器目录。
+   */
+  const applyFor = (agent, catalog) => {
+    const sessionId = String(agent.id)
+    const deny = denyFor(sessionId, catalog)
+    const key = deny.join('\n')
+    const previous = installed.get(sessionId)
+    // 只有本代装下的、指纹相同的记录才算已就位。
+    if (previous !== undefined && previous.generation === generation && previous.key === key) return
+    clearSession(sessionId)
+    if (deny.length === 0) return
+    const agentTools = agent.ctx?.tools
+    if (agentTools === undefined) return
+    const record = { generation, key, dispose: undefined }
+    installed.set(sessionId, record)
+    // 记录本代装过哪些会话：卸载时只清自己的记录，不动下一代已经接手的那批。
+    mine.add(sessionId)
+    try {
+      // 用插件自己的 ctx 包一层 effect，让掩码有第二个持有点。
+      record.dispose = ctx.effect(() => agentTools.restrict({ deny }), 'mcp-toggles: mask')
+      log?.debug?.(`mcp-toggles: session ${sessionId} hides ${deny.length} MCP tool(s)`)
+    } catch (error) {
+      // `restrict` 对未知名字抛错：服务器刚断线时工具可能在两次读取之间消失。
+      // 收尾那一轮会用新的名字集合重算，所以这里不放大成故障。
+      if (installed.get(sessionId) === record) installed.delete(sessionId)
+      mine.delete(sessionId)
+      log?.debug?.(`mcp-toggles: cannot install mask for ${sessionId}: ${String(error?.message ?? error)}`)
+    }
+  }
+
+  /** 正在对账；期间到来的变更折叠成收尾的一轮。 */
+  let reconciling = false
+  /** 对账期间是否又有变更要求重算。 */
+  let rescan = false
+
+  /**
+   * 对全部在线 agent 对账一次。
+   *
+   * 与 `tools/change` 的自激靠两层挡住：deny 指纹相同的会话直接跳过；期间的
+   * 同步重入只置 `rescan`，不嵌套执行，收尾时再跑一轮。
+   */
+  const reconcile = () => {
+    if (reconciling) {
+      rescan = true
+      return
+    }
+    reconciling = true
+    try {
+      do {
+        rescan = false
+        const catalog = serverCatalog()
+        const agents = ctx.get('agents')
+        for (const agent of agents?.list?.() ?? []) applyFor(agent, catalog)
+      } while (rescan)
+    } finally {
+      reconciling = false
+    }
+  }
+
+  // 新会话：装配它的掩码；已存在的会话在插件加载时补装。
+  ctx.on('agent/created', (payload) => {
+    if (payload?.agent !== undefined) reconcile()
+  })
+  ctx.on('agent/disposed', (payload) => {
+    const agent = payload?.agent
+    // 掩码注册在 agent 作用域上，随作用域一起销毁，这里只丢弃记录。
+    if (agent !== undefined) installed.delete(String(agent.id))
+  })
+  // 工具集合变化（服务器重连、工具列表更新）：对账，指纹挡住自激。
+  ctx.on('tools/change', () => { reconcile() })
+
+  ctx.effect(() => {
+    reconcile()
+    return () => {
+      // 只清本代装过的会话：下一代模块在重载时已接手同一张表，误清会连带
+      // 撤销它刚装好的掩码。
+      for (const sessionId of [...mine]) clearSession(sessionId)
+      mine.clear()
+    }
+  }, 'mcp-toggles: per-session masks')
+
+  // #endregion
+
+  // #region 路由
+
+  const sendJson = (res, status, body) => {
+    const payload = JSON.stringify(body)
+    res.writeHead(status, {
+      'content-type': 'application/json; charset=utf-8',
+      'cache-control': 'no-store',
+      'content-length': Buffer.byteLength(payload),
+    })
+    res.end(payload)
+  }
+
+  const readBody = async (req) => {
+    const chunks = []
+    let total = 0
+    for await (const chunk of req) {
+      total += chunk.length
+      if (total > MAX_BODY_BYTES) throw new Error('请求体过大')
+      chunks.push(chunk)
+    }
+    if (chunks.length === 0) return {}
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+  }
+
+  /** 同源 + 令牌校验。 */
+  const authorize = (req) => {
+    if (req.headers[TOKEN_HEADER] !== token) return false
+    const site = req.headers['sec-fetch-site']
+    if (site !== undefined && site !== 'same-origin' && site !== 'none') return false
+    const origin = req.headers.origin
+    if (origin !== undefined) {
+      try {
+        if (new URL(origin).origin !== ctx.webServer.getOrigin()) return false
+      } catch {
+        return false
+      }
+    }
+    return true
+  }
+
+  /** 某会话的状态投影，供选择器渲染。 */
+  const snapshot = (sessionId) => {
+    const catalog = serverCatalog()
+    const servers = catalog.map(server => ({
+      name: server.name,
+      transport: server.transport,
+      target: server.target,
+      tools: server.tools.length,
+      connected: server.connected,
+      enabled: isEnabled(sessionId, server.name),
+    }))
+    return {
+      session: sessionId,
+      servers,
+      enabledCount: servers.filter(server => server.enabled).length,
+      sharedResourceTools: config.sharedResourceTools,
+      shadowedTools: denyFor(sessionId, catalog).length,
+      installed: installed.has(sessionId),
+    }
+  }
+
+  /** 写入某会话的一个开关，并对该会话立即生效。 */
+  const setSwitch = (sessionId, serverName, enabled) => {
+    const row = state.bySession[sessionId] ?? (state.bySession[sessionId] = {})
+    if (enabled) delete row[serverName]
+    else row[serverName] = false
+    if (Object.keys(row).length === 0) delete state.bySession[sessionId]
+    const persisted = saveState(state)
+    reconcile()
+    return persisted
+  }
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: API_PREFIX,
+    handler: async (req, res) => {
+      const url = new URL(req.url ?? '/', ctx.webServer.getOrigin())
+      const route = url.pathname.slice(API_PREFIX.length) || '/'
+
+      if (route === '/token' && req.method === 'GET') {
+        return sendJson(res, 200, { token })
+      }
+      if (!authorize(req)) {
+        return sendJson(res, 403, { ok: false, error: { code: 'forbidden', message: '未授权' } })
+      }
+
+      try {
+        if (route === '/state' && req.method === 'GET') {
+          const sessionId = url.searchParams.get('session')
+          if (sessionId === null || sessionId.length === 0) {
+            return sendJson(res, 400, { ok: false, error: { code: 'missing-session', message: '缺少会话 id' } })
+          }
+          return sendJson(res, 200, { ok: true, ...snapshot(sessionId) })
+        }
+
+        if (route === '/toggle' && req.method === 'POST') {
+          const body = await readBody(req)
+          const sessionId = typeof body.session === 'string' ? body.session : ''
+          if (sessionId.length === 0) {
+            return sendJson(res, 400, { ok: false, error: { code: 'missing-session', message: '缺少会话 id' } })
+          }
+          if (typeof body.enabled !== 'boolean') {
+            return sendJson(res, 400, { ok: false, error: { code: 'invalid-enabled', message: 'enabled 必须是布尔值' } })
+          }
+          // `server === null` 表示整组开/关。
+          if (body.server === null || body.server === undefined) {
+            const catalog = serverCatalog()
+            for (const server of catalog) {
+              const row = state.bySession[sessionId] ?? (state.bySession[sessionId] = {})
+              if (body.enabled) delete row[server.name]
+              else row[server.name] = false
+            }
+            if (state.bySession[sessionId] !== undefined
+              && Object.keys(state.bySession[sessionId]).length === 0) {
+              delete state.bySession[sessionId]
+            }
+            const persisted = saveState(state)
+            reconcile()
+            return sendJson(res, 200, { ok: true, persisted, ...snapshot(sessionId) })
+          }
+          if (typeof body.server !== 'string' || body.server.length === 0) {
+            return sendJson(res, 400, { ok: false, error: { code: 'invalid-server', message: 'server 必须是字符串' } })
+          }
+          const known = serverCatalog().some(server => server.name === body.server)
+          if (!known) {
+            return sendJson(res, 404, {
+              ok: false,
+              error: { code: 'unknown-server', message: `未安装的 MCP 服务器：${body.server}` },
+            })
+          }
+          const persisted = setSwitch(sessionId, body.server, body.enabled)
+          return sendJson(res, 200, { ok: true, persisted, ...snapshot(sessionId) })
+        }
+
+        return sendJson(res, 404, { ok: false, error: { code: 'not-found', message: '未知路由' } })
+      } catch (error) {
+        return sendJson(res, 500, { ok: false, error: { code: 'internal', message: String(error?.message ?? error) } })
+      }
+    },
+  }), 'mcp-toggles: routes')
+
+  // 页面早于插件加载时，客户端从 meta 拿令牌；插件的 tap 负责把它写进去。
+  ctx.effect(() => ctx.webServer.tapIndex((html) => {
+    if (html.includes(`name="${TOKEN_META_NAME}"`)) return html
+    const meta = `<meta name="${TOKEN_META_NAME}" content="${token}">`
+    const head = html.indexOf('</head>')
+    return head === -1 ? meta + html : html.slice(0, head) + meta + html.slice(head)
+  }), 'mcp-toggles: token meta')
+
+  // #endregion
+}
+
+// #endregion

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "MCP per conversation",
+    "description": "Adds a picker to each conversation header that lists the installed MCP servers and turns each one on or off for that conversation only."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "按会话开关 MCP",
+    "description": "在每个会话的标题栏添加一个选择按钮，列出已安装的 MCP 服务器，并可单独开启或关闭，只影响当前会话。"
+  }
+}

package/package.json

@@ -1,6 +1,68 @@
 {
   "name": "dsh-plugin-mcp-toggles",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Turn installed MCP servers on or off per conversation, from a picker in the session header.",
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "dsh-plugin",
+    "mcp",
+    "model-context-protocol",
+    "plugin"
+  ],
+  "homepage": "https://github.com/ZhaoHanshao/dsh-plugin-mcp-toggles#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ZhaoHanshao/dsh-plugin-mcp-toggles.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ZhaoHanshao/dsh-plugin-mcp-toggles/issues"
+  },
+  "author": "ZhaoHanshao",
+  "license": "MIT",
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-client-ui-conversation": ">=0.2.1-rc.3"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-client-ui-conversation": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "prepublishOnly": "node --check lib/index.js && node --check lib/client.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}