@moon16u/dsh-plugin-mcp-console 0.1.2 → 0.2.0

package/README.md

@@ -29,20 +29,28 @@ Then open DSH Web → bottom-left Settings → **"MCP servers"**.
 | Capability | Description |
 |---|---|
 | Server management | Add (stdio / streamable-http forms), edit, delete, enable/disable, reconnect; config changes take effect immediately, no DSH restart |
+| Connection test | One-click "Test connection" per server: a throwaway official-client fiber (with `failOnStartupError` forced on) performs a real handshake and reports tool count + latency; for a running server it honestly reports the live status instead (the official client's serverName namespace cannot be bypassed) |
 | Per-tool switches | Expand a server card and click tool pills to toggle individual tools; disabled tools are denied at execution time by a guard |
 | Live status | running / connecting / starting / disabled / failed grading; SSE push updates, tool counts in real time |
 | JSON import | Paste Claude / Cursor style `mcpServers` JSON, preview, import; existing names skipped and reported |
 | Auto-ingest | MCP entries written into `cordis.patch.yml` by external agents/scripts are migrated into dynamic management on boot and on "Sync config & refresh status" (store persists before the YAML is trimmed — configuration is never lost) |
 | YAML export | `POST /api/dsh-mcp-console/export-yaml` restores dynamic config as standard `cordis.patch.yml` entries (uninstall/backup reversibility) |
+| Model awareness | A `ctx.systemPrompt.section` announcement tells every agent that MCP management lives in the settings page, not in hand-edited config files (own inject scope; dormant on hosts without the service) |
+| Settings integration | `enabled` / `announceToAgent` master switches registered against the official settings provider (`mcp-console` namespace, dual-generation API): editable from the settings GUI with live effect — `enabled` tears the whole surface down (routes + MCP connections + announcement; stores preserved), `announceToAgent` toggles only the announcement; hosts without the service fall back to entry defaults |
+| Settings-GUI card | The "MCP console" card on Settings → Plugins (`settings.plugin.item`, key `mcp-console`): collapsible and shaped like the official cards (same `--dsw-alias-*` tokens and metrics), switches write immediately, and a changed field carries a "Customized" badge with its own reset |
+| Degraded state | With `enabled` off, the "MCP servers" page stops reporting an API error and shows the switched-off notice plus the way back (an authenticated 404 on our own prefix is the tell), and keeps the SSE stream closed instead of retrying |
 
 ## Config storage
 
 - Dynamic config: `~/.dsh/dsh-mcp.json` (versioned JSON, atomic writes: temp file + rename; deletions are explicit user intent, no backup files are kept)
+- Plugin switches: the official settings user document's `mcp-console` section (edited via the settings GUI, persisted by the provider)
 - Profile layer: `~/.dsh/profiles/web/cordis.patch.yml` (the ingest engine touches only mcp-client entries; other entries and comments are preserved verbatim)
 
 ## HTTP API (loopback-only, prefix `/api/dsh-mcp-console/`)
 
-`GET /health` · `GET/POST /servers` · `PATCH/DELETE /servers/:name` · `POST /servers/:name/enable|disable|reconnect` · `POST /refresh` (ingest YAML + retry failed) · `POST /import` · `POST /export-yaml` · `GET /events` (SSE) · `GET/PUT /config` (UI config)
+`GET /health` · `GET/POST /servers` · `PATCH/DELETE /servers/:name` · `POST /servers/:name/enable|disable|reconnect|probe` · `POST /refresh` (ingest YAML + retry failed) · `POST /import` · `POST /export-yaml` · `GET /events` (SSE) · `GET/PUT /config` (UI config)
+
+**Four-layer loopback fence** (borrowed from dsh-skills-mcp-manager): loopback socket peer, loopback Host header (DNS-rebinding fence), no `sec-fetch-site: cross-site` marker, and — when Origin is present — an Origin matching the Host. `GET /config` (UI placement only) stays open to LAN browsers.
 
 ## Known limitations (honest wording)
 
@@ -50,11 +58,12 @@ Then open DSH Web → bottom-left Settings → **"MCP servers"**.
 2. **Per-tool disable exposure**: `tools.restrict()` requires an agent scope in dsh-tools (context-global restriction is explicitly forbidden), so a disabled tool still appears in the model's tool list — but its calls are denied by the guard with a clear reason.
 3. **First-migration boot race**: with small probability the loader and the ingest engine assemble the same serverName during boot; the loader-side fiber logs one duplicate error (harmless — the YAML is already trimmed, so it does not recur on the next boot).
 4. **rc-version coupling**: depends on cordis/webserver/tools contracts of the official packages; all official-package coupling is isolated in `clientAdapter.js` (the official client is resolved dynamically from the profile's module graph, sharing the loader's module instance) and `routes.js`.
+5. **"Test connection" on a running server**: the official client reserves the serverName namespace per module instance, so a live server cannot be re-probed alongside its own fiber; the button then returns the live status (`live: true`) instead of a fresh handshake. Fresh side-fiber probes carry a hard 15s timeout.
 
 ## Development
 
 ```bash
-pnpm --filter @moon16u/dsh-plugin-mcp-console test     # 43 tests
+pnpm --filter @moon16u/dsh-plugin-mcp-console test     # 73 tests
 node scripts/sync-root-client.mjs                      # after editing lib/client.js, sync into the pouch root bundle
 ```
 

package/README.zh-CN.md

@@ -22,20 +22,28 @@ dsh plugin --profile web add @moon16u/dsh-plugin-mcp-console
 | 能力 | 说明 |
 |---|---|
 | 服务器管理 | 新增（stdio / streamable-http 双模式表单）、编辑、删除、启停、重连；改配置即时生效，无需重启 dsh（删除即用户意志，不留备份文件） |
+| 连接测试 | 每台服务器一键「测试连接」：起一个一次性官方 client fiber（强制 `failOnStartupError`）真实握手，报告工具数与延迟；对运行中的服务器则如实报告实时状态（官方 client 的 serverName 命名空间不允许旁路重连） |
 | 工具级开关 | 展开服务器卡片，点击工具胶囊单独启停；禁用的工具调用会被执行期 guard 拒绝 |
 | 实时状态 | 运行中/连接中/启动中/已停用/失败 分级；SSE 推送刷新，工具数实时联动 |
 | JSON 导入 | 粘贴 Claude / Cursor 风格 `mcpServers` JSON，预览后导入，同名跳过并报告 |
 | Auto-Ingest | 外部 agent / 脚本按官方推荐写入 `cordis.patch.yml` 的 MCP 条目，在启动与「同步配置并刷新状态」时自动移入动态管理（store 持久化成功才修剪 YAML，绝不丢配置） |
 | YAML 回写 | `POST /api/dsh-mcp-console/export-yaml` 把动态配置一键还原为标准 `cordis.patch.yml` 条目（卸载/备份可逆） |
+| 模型感知 | 通过 `ctx.systemPrompt.section` 向每个 agent 的系统提示注入一段公告：MCP 管理请到设置页操作，勿手改配置文件（独立 inject 作用域，无该服务的宿主上自动休眠） |
+| 设置集成 | `enabled` / `announceToAgent` 总开关走官方 settings provider（`mcp-console` 命名空间，双世代 API 兼容），设置 GUI 可改、即改即生效：`enabled` 关闭整体下线（路由 + MCP 连接 + 公告，store 保留），`announceToAgent` 只控制公告；无 settings 服务的宿主回落条目默认值 |
+| 设置 GUI 卡片 | 设置 → 插件 页的「MCP 控制台」卡片（`settings.plugin.item`，键 `mcp-console`）：可折叠、与官方卡片同形（同一批 `--dsw-alias-*` 令牌与尺寸），开关即改即写，被改过的字段带「已自定义」徽章与逐字段「恢复默认」 |
+| 停用后的降级 | `enabled` 关闭后「MCP 服务器」页不再报接口错误，改为显示停用提示与恢复入口（自有前缀路由的 404 即判定为已停用），并停开 SSE 以免反复重试 |
 
 ## 配置存储
 
 - 动态配置：`~/.dsh/dsh-mcp.json`（版本化 JSON，原子写：临时文件 + rename，不产生备份文件）
+- 插件开关：DSH 官方 settings 用户文档的 `mcp-console` 节（设置 GUI 编辑、官方持久化）
 - profile 层：`~/.dsh/profiles/web/cordis.patch.yml`（ingest 引擎只动其中的 mcp-client 条目，其余条目与注释原样保留）
 
 ## HTTP API（loopback-only，前缀 `/api/dsh-mcp-console/`）
 
-`GET /health` · `GET/POST /servers` · `PATCH/DELETE /servers/:name` · `POST /servers/:name/enable|disable|reconnect` · `POST /refresh`（吸纳 YAML + 重试失败）· `POST /import` · `POST /export-yaml` · `GET /events`（SSE）· `GET/PUT /config`（UI 配置）
+`GET /health` · `GET/POST /servers` · `PATCH/DELETE /servers/:name` · `POST /servers/:name/enable|disable|reconnect|probe` · `POST /refresh`（吸纳 YAML + 重试失败）· `POST /import` · `POST /export-yaml` · `GET /events`（SSE）· `GET/PUT /config`（UI 配置）
+
+**回环围栏四层校验**（借鉴 dsh-skills-mcp-manager）：socket 对端地址、Host 头必须是回环源（防 DNS rebinding）、拒绝 `sec-fetch-site: cross-site`、Origin（若携带）必须与 Host 同源。`GET /config`（仅 UI 位置）对局域网浏览器开放。
 
 ## 已知限制（诚实口径）
 
@@ -43,11 +51,12 @@ dsh plugin --profile web add @moon16u/dsh-plugin-mcp-console
 2. **工具级禁用的暴露面**：`tools.restrict()` 在 dsh-tools 中要求 agent-scope（全局限制被明确禁止），故被禁用的工具仍出现在模型工具列表中，但调用被 guard 拒绝并在结果中说明。
 3. **首次迁移的启动竞态**：极小概率下 boot 期 loader 与 ingest 引擎同时装配同一 serverName，loader 侧 fiber 会报一次 duplicate 错误（无害，下次启动 YAML 已修剪，不再复现）。
 4. **rc 版本耦合**：依赖官方包的 cordis/webserver/tools 契约，收敛在 `clientAdapter.js`（动态解析 profile 里的官方 client，与 loader 共享同一模块实例）与 `routes.js`。
+5. **运行中服务器的「测试连接」**：官方 client 的 serverName 命名空间按模块实例保留，运行中的服务器无法旁路重连测试；此时按钮返回实时状态（`live: true`）而非新握手结果。新握手探测硬超时 15s。
 
 ## 开发
 
 ```bash
-pnpm --filter @moon16u/dsh-plugin-mcp-console test     # 42 个测试
+pnpm --filter @moon16u/dsh-plugin-mcp-console test     # 73 个测试
 node scripts/sync-root-client.mjs                      # 改 lib/client.js 后同步进 dsh-pouch 根 bundle
 ```
 

package/lib/client.js

@@ -84,6 +84,27 @@ window.__ModuleLoader__.load({
       disabled: "已停用",
       failed: "失败",
       toolDeniedNote: "禁用的工具仍保留在模型工具列表中，但调用会被拒绝。",
+      test: "测试连接",
+      probeBusy: "测试中…",
+      probeOk: "连接成功 · {n} 个工具 · {ms}ms",
+      probeLiveOk: "已在运行 · {n} 个工具（实时状态）",
+      probeLiveFail: "未正常连接（实时状态）：{error}",
+      probeFail: "连接失败：{error}",
+      pluginCardTitle: "MCP 控制台",
+      pluginCardDesc: "MCP 服务器的连接、工具开关与导入。",
+      pluginCardEnabled: "启用 MCP 控制台",
+      pluginCardEnabledHelp: "关闭后：路由、全部 MCP 连接与模型公告下线；配置保留在 ~/.dsh/dsh-mcp.json",
+      pluginCardAnnounce: "向模型公告 MCP 管理能力",
+      pluginCardAnnounceHelp: "在系统提示中告知 agent：MCP 管理请到设置页操作，不要手改配置文件",
+      pluginCardOverridden: "已自定义",
+      pluginCardReset: "恢复默认",
+      sectionOffline: "MCP 控制台当前已停用。",
+      sectionOfflineHint: "到 设置 → 插件 → MCP 控制台 打开「启用 MCP 控制台」即可恢复；服务器配置一直保留在 ~/.dsh/dsh-mcp.json。",
+      pluginCardExpand: "展开设置",
+      pluginCardCollapse: "收起设置",
+      pluginCardUnavailable: "此客户端未暴露插件设置（只读或本地模式）。",
+      pluginCardLoading: "加载中…",
+      pluginCardWriteError: "写入失败",
     };
 
     var mcpEn = {
@@ -152,6 +173,27 @@ window.__ModuleLoader__.load({
       disabled: "Disabled",
       failed: "Failed",
       toolDeniedNote: "Disabled tools stay in the model tool list, but their calls are denied.",
+      test: "Test connection",
+      probeBusy: "Testing…",
+      probeOk: "Connected · {n} tools · {ms}ms",
+      probeLiveOk: "Running · {n} tools (live status)",
+      probeLiveFail: "Not healthy (live status): {error}",
+      probeFail: "Connection failed: {error}",
+      pluginCardTitle: "MCP console",
+      pluginCardDesc: "Connections, per-tool switches and import for MCP servers.",
+      pluginCardEnabled: "Enable the MCP console",
+      pluginCardEnabledHelp: "Off: routes, every MCP connection and the model announcement go offline; config stays in ~/.dsh/dsh-mcp.json",
+      pluginCardAnnounce: "Announce MCP management to the model",
+      pluginCardAnnounceHelp: "Tells agents in the system prompt to use the settings page for MCP management, not hand-edited files",
+      pluginCardOverridden: "Customized",
+      pluginCardReset: "Reset to defaults",
+      sectionOffline: "The MCP console is switched off.",
+      sectionOfflineHint: "Turn \"Enable the MCP console\" back on under Settings → Plugins → MCP console; server configuration stays in ~/.dsh/dsh-mcp.json.",
+      pluginCardExpand: "Expand settings",
+      pluginCardCollapse: "Collapse settings",
+      pluginCardUnavailable: "Plugin settings are not exposed to this client (read-only or local mode).",
+      pluginCardLoading: "Loading…",
+      pluginCardWriteError: "Write failed",
     };
 
     var mcpCss = [
@@ -194,6 +236,37 @@ window.__ModuleLoader__.load({
       ".mcp-mgr-name-btn{background:0 0;border:0;padding:0;color:inherit;font-family:inherit;font-size:inherit;font-weight:inherit;cursor:pointer;text-align:left;min-width:0}",
       ".mcp-mgr-name-btn:hover{text-decoration:underline;text-underline-offset:3px}",
       ".mcp-mgr-err{color:var(--dsw-alias-state-error-primary,#ef4444);margin:0;font-size:12px;word-break:break-word}",
+      ".mcp-probe{margin:0;font-size:12px;line-height:18px;word-break:break-word}",
+      ".mcp-probe[data-tone=run]{color:var(--dsw-alias-label-secondary,#6b7280)}",
+      ".mcp-probe[data-tone=ok]{color:var(--dsw-alias-state-success-primary,#10b981)}",
+      ".mcp-probe[data-tone=bad]{color:var(--dsw-alias-state-error-primary,#ef4444)}",
+      ".mcp-plugin-card{list-style:none;margin:0;border:.5px solid var(--dsw-alias-border-l4,#e5e7eb);border-radius:16px;background:var(--dsw-alias-bg-layer-3,#ffffff);transition:border-color .16s,background .16s}",
+      ".mcp-plugin-card:hover{border-color:var(--dsw-alias-label-dimmed,#d1d5db)}",
+      ".mcp-plugin-card[data-open=true]{background:var(--dsw-alias-bg-layer-2,#fafafa);border-color:var(--dsw-alias-label-dimmed,#d1d5db)}",
+      ".mcp-plugin-header{appearance:none;width:100%;font:inherit;color:inherit;text-align:left;cursor:pointer;background:0 0;border:0;border-radius:12px;display:flex;align-items:center;gap:12px;padding:14px 16px}",
+      ".mcp-plugin-header:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#4d6bfe);outline-offset:-2px}",
+      ".mcp-plugin-headtext{display:flex;flex-direction:column;flex:1;gap:4px;min-width:0}",
+      ".mcp-plugin-name{color:var(--dsw-alias-label-primary,#111827);font-size:15px;font-weight:600;line-height:1.4}",
+      ".mcp-plugin-desc{color:var(--dsw-alias-label-tertiary,#9ca3af);font-size:13px;line-height:1.5}",
+      ".mcp-plugin-chevron{color:var(--dsw-alias-label-tertiary,#9ca3af);flex:none;transition:transform .16s}",
+      ".mcp-plugin-card[data-open=true] .mcp-plugin-chevron{transform:rotate(180deg)}",
+      ".mcp-plugin-body{border-top:.5px solid var(--dsw-alias-border-l2,#e5e7eb);margin:0 16px;padding-bottom:8px}",
+      ".mcp-plugin-field{display:flex;flex-direction:column;gap:6px;padding:12px 0}",
+      ".mcp-plugin-field + .mcp-plugin-field{border-top:.5px solid var(--dsw-alias-border-l2,#e5e7eb)}",
+      ".mcp-plugin-field-head{display:flex;align-items:center;gap:8px;color:var(--dsw-alias-label-primary,#111827);font-size:13px;line-height:1.5}",
+      ".mcp-plugin-field-label{flex:1;min-width:0;font-weight:500}",
+      ".mcp-plugin-badge{flex:none;white-space:nowrap;background:var(--dsw-alias-bg-module-platform,#f3f4f6);color:var(--dsw-alias-label-secondary,#6b7280);border-radius:999px;padding:1px 8px;font-size:11px;font-weight:500;line-height:17px}",
+      ".mcp-plugin-reset{flex:none;font:inherit;color:var(--dsw-alias-label-secondary,#6b7280);cursor:pointer;background:0 0;border:none;padding:0;font-size:12px;line-height:1.5}",
+      ".mcp-plugin-reset:hover:not(:disabled){color:var(--dsw-alias-label-primary,#111827)}",
+      ".mcp-plugin-reset:disabled{cursor:default;opacity:.5}",
+      ".mcp-plugin-switch{box-sizing:border-box;flex:none;position:relative;width:36px;height:20px;padding:2px;border:0;border-radius:10px;cursor:pointer;background:var(--dsw-alias-border-l3,#d1d5db);transition:background .12s}",
+      ".mcp-plugin-switch[aria-checked=true]{background:var(--dsw-alias-brand-primary,#4d6bfe)}",
+      ".mcp-plugin-switch:disabled{cursor:default;opacity:.5}",
+      ".mcp-plugin-switch:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#4d6bfe);outline-offset:2px}",
+      ".mcp-plugin-thumb{display:block;width:16px;height:16px;border-radius:50%;background:var(--dsw-alias-label-primary-foreground,#ffffff);transition:transform .12s}",
+      ".mcp-plugin-switch[aria-checked=true] .mcp-plugin-thumb{transform:translateX(16px)}",
+      ".mcp-plugin-hint{color:var(--dsw-alias-label-tertiary,#9ca3af);margin:0;font-size:12px;line-height:1.5}",
+      ".mcp-plugin-err{color:var(--dsw-alias-state-error-primary,#ef4444);font-size:12px;line-height:1.5;margin:0;padding-bottom:4px;word-break:break-word}",
       ".mcp-mgr-tools{display:flex;flex-wrap:wrap;gap:8px;padding-top:4px}",
       ".mcp-pill-wrap{position:relative;display:inline-flex}",
       ".mcp-pill{border:1px solid var(--dsw-alias-border-l2,#e5e7eb);background:var(--dsw-alias-bg-base,#ffffff);color:var(--dsw-alias-label-primary,#374151);border-radius:6px;padding:3px 10px;font-size:12px;line-height:18px;font-family:var(--ds-font-family-code,ui-monospace,monospace);cursor:pointer;transition:all .15s ease;user-select:none}",
@@ -273,14 +346,28 @@ window.__ModuleLoader__.load({
         } catch {}
         if (!response.ok) {
           var message = body && body.error && body.error.message ? body.error.message : response.status + " " + response.statusText;
-          throw new Error(message);
+          var failure = new Error(message);
+          // the console's own prefix route only disappears when the master
+          // switch took the composition down — the section reads this to say
+          // "disabled" instead of showing a raw API error
+          failure.status = response.status;
+          throw failure;
         }
         return body;
       });
     }
 
-    function mcpFill(template, values) {
-      return String(template).replace(/\{(\w+)\}/g, function (_, key) {
+    /**
+     * Whether an mcpApi failure means "the console is switched off" rather than
+     * a genuine API error: only our own prefix route answers under
+     * /api/dsh-mcp-console, so an authenticated 404 there is the composition
+     * being torn down by the `enabled` master switch.
+     */
+    function mcpConsoleOffline(failure) {
+      return Boolean(failure) && failure.status === 404;
+    }
+
+    function mcpFill(template, values) {      return String(template).replace(/\{(\w+)\}/g, function (_, key) {
         return Object.prototype.hasOwnProperty.call(values, key) ? String(values[key]) : "{" + key + "}";
       });
     }
@@ -341,11 +428,32 @@ window.__ModuleLoader__.load({
     }
 
     /**
-     * One server item: header row (name + status + badge | delete + master
-     * switch), summary row (chevron + count, expand trigger), tool pills.
-     * Read-only entries (profile-declared, review §2-4) hide delete, disable
-     * switch and pills, and skip tooltips. Editing opens by clicking the
-     * server name (the explicit edit button is gone per review §2-2).
+     * One probe outcome line ("Test connection"): busy / connected-with-
+     * latency / live-status report / failure. null while never probed.
+     */
+    function mcpProbeLine(probe, t) {
+      if (probe.busy === true) {
+        return McpH("p", { className: "mcp-probe", "data-tone": "run" }, t("probeBusy"));
+      }
+      if (probe.ok) {
+        return McpH("p", { className: "mcp-probe", "data-tone": "ok" },
+          probe.live === true
+            ? mcpFill(t("probeLiveOk"), { n: probe.toolCount })
+            : mcpFill(t("probeOk"), { n: probe.toolCount, ms: probe.latencyMs }));
+      }
+      return McpH("p", { className: "mcp-probe", "data-tone": "bad" },
+        probe.live === true
+          ? mcpFill(t("probeLiveFail"), { error: probe.error || "" })
+          : mcpFill(t("probeFail"), { error: probe.error || "" }));
+    }
+
+    /**
+     * One server item: header row (name + status + badge | test + delete +
+     * master switch), summary row (chevron + count, expand trigger), probe
+     * result line, tool pills. Read-only entries (profile-declared, review
+     * §2-4) hide test, delete, disable switch and pills, and skip tooltips.
+     * Editing opens by clicking the server name (the explicit edit button is
+     * gone per review §2-2).
      */
     function McpServerItem(props) {
       var t = props.t;
@@ -373,6 +481,12 @@ window.__ModuleLoader__.load({
           McpH("span", { className: "mcp-dot", "data-status": server.status, title: statusLabel, key: "dot" }),
           readOnly ? McpH("span", { className: "mcp-readonly-badge", title: t("profileReadOnly") }, t("profileReadOnly")) : null,
           McpH("span", { className: "mcp-mgr-ops" },
+            readOnly ? null : McpH("button", {
+              type: "button", className: "mcp-mgr-iconbtn",
+              disabled: busy || (props.probe && props.probe.busy === true),
+              title: t("test"), "aria-label": t("test"),
+              onClick: function () { props.onProbe(server); },
+            }, McpH(McpIcons.IconLinkOutline16, { size: 14 })),
             readOnly ? null : McpH("button", {
               type: "button", className: "mcp-mgr-del", disabled: busy,
               title: t("remove"), "aria-label": t("remove"),
@@ -390,6 +504,7 @@ window.__ModuleLoader__.load({
           },
             McpH("span", { className: "mcp-mgr-chevron" }),
             McpH("span", null, summary))),
+        props.probe ? mcpProbeLine(props.probe, t) : null,
         server.error ? McpH("p", { className: "mcp-mgr-err" }, t("errorPrefix") + ": " + server.error) : null,
         open
           ? (server.toolCount === 0
@@ -694,11 +809,26 @@ window.__ModuleLoader__.load({
       var expanded = expandedState[0], setExpanded = expandedState[1];
       var refreshingState = useState(false);
       var refreshing = refreshingState[0], setRefreshing = refreshingState[1];
+      var probeState = useState({});
+      var probes = probeState[0], setProbes = probeState[1]; // name -> {busy}|result
+      var offlineState = useState(false);
+      var offline = offlineState[0], setOffline = offlineState[1];
+
+      /** A 404 on our own prefix means the master switch took the routes down. */
+      function receiveFailure(failure) {
+        if (mcpConsoleOffline(failure)) {
+          setOffline(true);
+          setError(null);
+          return;
+        }
+        setError(failure instanceof Error ? failure.message : String(failure));
+      }
 
       function load() {
-        return mcpApi("/servers").then(setSnapshot, function (failure) {
-          setError(failure instanceof Error ? failure.message : String(failure));
-        });
+        return mcpApi("/servers").then(function (body) {
+          setOffline(false);
+          setSnapshot(body);
+        }, receiveFailure);
       }
 
       useEffect(function () {
@@ -706,13 +836,17 @@ window.__ModuleLoader__.load({
         mcpApi("/servers").then(function (body) {
           if (!stale) setSnapshot(body);
         }, function (failure) {
-          if (!stale) setError(failure instanceof Error ? failure.message : String(failure));
+          if (!stale) receiveFailure(failure);
         });
         return function () { stale = true; };
       }, []);
 
       // Live updates while the settings page is open (plan §5.4 /events).
+      // Opened only once data arrived: with the console switched off the route
+      // is gone, and EventSource would retry the 404 every few seconds.
+      var streamReady = snapshot !== null;
       useEffect(function () {
+        if (!streamReady) return undefined;
         var source = new EventSource("/api/dsh-mcp-console/events");
         source.addEventListener("status_changed", function (event) {
           try {
@@ -720,7 +854,7 @@ window.__ModuleLoader__.load({
           } catch {}
         });
         return function () { source.close(); };
-      }, []);
+      }, [streamReady]);
 
       useEffect(function () {
         function onKey(event) {
@@ -779,6 +913,35 @@ window.__ModuleLoader__.load({
         setConfirm(server.name);
       }
 
+      /**
+       * "Test connection" (borrowed from dsh-skills-mcp-manager): the host
+       * loads one throwaway official-client fiber, so the outcome (tools,
+       * latency, error) is a real handshake result. Results live per card,
+       * separate from withBusy so a probe never blocks other controls.
+       */
+      function probeServer(server) {
+        setProbes(function (previous) {
+          var next = { ...previous };
+          next[server.name] = { busy: true };
+          return next;
+        });
+        mcpApi("/servers/" + encodeURIComponent(server.name) + "/probe", { method: "POST" }).then(
+          function (result) {
+            setProbes(function (previous) {
+              var next = { ...previous };
+              next[server.name] = result;
+              return next;
+            });
+          },
+          function (failure) {
+            setProbes(function (previous) {
+              var next = { ...previous };
+              next[server.name] = { ok: false, live: false, toolCount: 0, latencyMs: null, error: failure instanceof Error ? failure.message : String(failure) };
+              return next;
+            });
+          });
+      }
+
       function confirmRemove() {
         var name = confirmName;
         setConfirm(null);
@@ -834,6 +997,8 @@ window.__ModuleLoader__.load({
           onToggleServer: toggleServer,
           onToggleTool: toggleTool,
           onRemove: removeServer,
+          onProbe: probeServer,
+          probe: probes[server.name],
           onEdit: function (target) { setEditing(target); setMode("edit"); },
         }));
       });
@@ -909,6 +1074,16 @@ window.__ModuleLoader__.load({
 
       var topDisabled = refreshing || mode !== null;
 
+      // Master switch off: the whole host side is down, so the page offers the
+      // way back instead of actions that cannot work.
+      if (offline) {
+        return McpH("div", { className: "mcp-mgr", "data-mcp-console-section": "", "data-mcp-console-offline": "" },
+          McpH("div", { className: "mcp-mgr-head" },
+            McpH("h2", { className: "mcp-mgr-title" }, t("title"))),
+          McpH("p", { className: "mcp-mgr-note" }, t("sectionOffline")),
+          McpH("p", { className: "mcp-ext" }, t("sectionOfflineHint")));
+      }
+
       return McpH("div", { className: "mcp-mgr", "data-mcp-console-section": "" },
         McpH("div", { className: "mcp-mgr-head" },
           McpH("h2", { className: "mcp-mgr-title" }, t("title")),
@@ -937,6 +1112,143 @@ window.__ModuleLoader__.load({
 
     var mcpInject = ["slots", "locale"];
 
+    /**
+     * Switch for the settings-GUI card: `role="switch"` button matching the
+     * official plugin cards on that page (their own component is not exported,
+     * so the shape is reproduced rather than imported).
+     */
+    function McpPluginSwitch(props) {
+      return McpH("button", {
+        type: "button",
+        role: "switch",
+        className: "mcp-plugin-switch",
+        "aria-checked": props.checked ? "true" : "false",
+        "aria-label": props.label,
+        disabled: props.disabled,
+        onClick: function () { props.onChange(!props.checked); },
+      }, McpH("span", { className: "mcp-plugin-thumb" }));
+    }
+
+    /**
+     * The settings-GUI card body: the enabled / announceToAgent master
+     * switches the host registered against the official settings provider.
+     * Exported separately from the card shell so the collapsed header and the
+     * fields can each be asserted on their own. A toggle writes through the
+     * client settings scope (serialized, revision-fenced); external edits
+     * arrive through the scope subscription and re-render live.
+     */
+    function McpPluginCardFields(props) {
+      var t = props.t;
+      var scope = props.scope;
+      var useState = React.useState;
+      var bumpState = React.useReducer(function (x) { return x + 1; }, 0);
+      var bump = bumpState[1];
+      React.useEffect(function () {
+        return scope ? scope.subscribe(function () { bump(); }) : undefined;
+      }, [scope]);
+      var busyState = useState(null); // null | "enabled" | "announceToAgent"
+      var busy = busyState[0], setBusy = busyState[1];
+      var errorState = useState(null);
+      var error = errorState[0], setError = errorState[1];
+
+      function writeFailure(failure) {
+        setError(t("pluginCardWriteError") + ": " + (failure && failure.message ? failure.message : String(failure)));
+      }
+
+      var snapshot = scope ? scope.getSnapshot() : null;
+      if (!snapshot || snapshot.status === "loading") {
+        return McpH("div", { className: "mcp-plugin-body" },
+          McpH("div", { className: "mcp-plugin-field" },
+            McpH("p", { className: "mcp-plugin-hint" }, t("pluginCardLoading"))));
+      }
+      if (snapshot.status === "unavailable") {
+        return McpH("div", { className: "mcp-plugin-body" },
+          McpH("div", { className: "mcp-plugin-field" },
+            McpH("p", { className: "mcp-plugin-hint" }, t("pluginCardUnavailable"))));
+      }
+      var value = snapshot.value ?? {};
+      var user = snapshot.user && typeof snapshot.user === "object" && !Array.isArray(snapshot.user) ? snapshot.user : {};
+      var writable = snapshot.writable !== false;
+
+      function settle(field) {
+        return [
+          function () { setBusy(null); },
+          function (failure) { setBusy(null); writeFailure(failure); },
+        ];
+      }
+      function write(field, next) {
+        setBusy(field);
+        setError(null);
+        var done = settle(field);
+        scope.set(field, next).then(done[0], done[1]);
+      }
+      function reset(field) {
+        setBusy(field);
+        setError(null);
+        var done = settle(field);
+        scope.unset(field).then(done[0], done[1]);
+      }
+
+      /** One boolean field: label + customized badge + per-field reset + switch, hint below. */
+      function field(key, label, help) {
+        var overridden = Object.prototype.hasOwnProperty.call(user, key);
+        return McpH("div", { className: "mcp-plugin-field", key: key },
+          McpH("div", { className: "mcp-plugin-field-head" },
+            McpH("span", { className: "mcp-plugin-field-label" }, label),
+            overridden ? McpH("span", { className: "mcp-plugin-badge" }, t("pluginCardOverridden")) : null,
+            overridden
+              ? McpH("button", {
+                  type: "button", className: "mcp-plugin-reset", disabled: busy !== null || !writable,
+                  onClick: function () { reset(key); },
+                }, t("pluginCardReset"))
+              : null,
+            McpH(McpPluginSwitch, {
+              label: label,
+              checked: value[key] !== false,
+              disabled: !writable || busy !== null,
+              onChange: function (next) { write(key, next); },
+            })),
+          McpH("p", { className: "mcp-plugin-hint" }, help));
+      }
+
+      return McpH("div", { className: "mcp-plugin-body" },
+        field("enabled", t("pluginCardEnabled"), t("pluginCardEnabledHelp")),
+        field("announceToAgent", t("pluginCardAnnounce"), t("pluginCardAnnounceHelp")),
+        error ? McpH("p", { className: "mcp-plugin-err" }, error) : null);
+    }
+
+    /**
+     * The settings-GUI card (settings.plugin.item, keyed "mcp-console"). The
+     * plugins tab lists a namespace only when its browser half also registers
+     * a card under that key, so this card is what actually surfaces the
+     * switches. Shape and collapse behavior follow the official cards on that
+     * page: a header button carrying name, description and chevron, with the
+     * fields revealed underneath.
+     */
+    function McpPluginCard(props) {
+      var t = props.t;
+      var openState = React.useState(false);
+      var open = openState[0], setOpen = openState[1];
+      var title = t("pluginCardTitle");
+      return McpH("li", {
+        className: "mcp-plugin-card",
+        "data-open": open ? "true" : "false",
+        "data-mcp-plugin-card": "",
+      },
+        McpH("button", {
+          type: "button",
+          className: "mcp-plugin-header",
+          "aria-expanded": open ? "true" : "false",
+          "aria-label": (open ? t("pluginCardCollapse") : t("pluginCardExpand")) + ": " + title,
+          onClick: function () { setOpen(!open); },
+        },
+          McpH("span", { className: "mcp-plugin-headtext" },
+            McpH("span", { className: "mcp-plugin-name" }, title),
+            McpH("span", { className: "mcp-plugin-desc" }, t("pluginCardDesc"))),
+          McpH(McpIcons.IconChevronDownOutline14, { size: 14, className: "mcp-plugin-chevron" })),
+        open ? McpH(McpPluginCardFields, { t: t, scope: props.scope }) : null);
+    }
+
     function mcpConsoleApply(ctx) {
       ctx.effect(function () {
         return ctx.locale.register(McpNS, { zh: mcpZh, en: mcpEn });
@@ -953,10 +1265,32 @@ window.__ModuleLoader__.load({
           inject: function () { return { t: mcpT }; },
         }, McpSection);
       });
+
+      // Settings-GUI card (settings.plugin.item keyed "mcp-console"): the
+      // host half registers the namespace against the official settings
+      // provider; this browser half supplies the card the plugins tab pairs
+      // with it. Deferred on the settingsScope service so hosts without the
+      // settings UI keep the console working (the section above stays).
+      ctx.inject(["settingsScope"], function (scope) {
+        var settingsScope = scope.settingsScope.bind({ namespace: "mcp-console" });
+        scope.slots.inject("settings.plugin.item", function () {
+          return scope.slots.register({
+            name: "settings.plugin.item",
+            key: "mcp-console",
+            locale: McpNS,
+            inject: function () { return { t: mcpT, scope: settingsScope }; },
+          }, McpPluginCard);
+        });
+      });
     }
 
     exports.McpSection = McpSection;
+    exports.McpServerItem = McpServerItem;
+    exports.McpPluginCard = McpPluginCard;
+    exports.McpPluginCardFields = McpPluginCardFields;
     exports.mcpConsoleApply = mcpConsoleApply;
+    exports.mcpConsoleOffline = mcpConsoleOffline;
+    exports.mcpDictionaries = { zh: mcpZh, en: mcpEn };
     exports.mcpInject = mcpInject;
 
     // ==== end mcp-console client body ====

package/lib/index.js

@@ -9,10 +9,16 @@
  * registration and reconnect belongs to the official client plugin, loaded
  * one fiber per server through `ctx.plugin()`.
  *
- * Service wiring uses `ctx.inject(["webServer", "tools"], ...)` rather than a
- * static `inject` export: on a host without the web profile (no webServer)
- * the plugin stays dormant instead of blocking the whole dsh-pouch bundle.
+ * Surface wiring uses dynamic `ctx.inject(...)` scopes rather than a static
+ * `inject` export: on a host without the web profile (no webServer) the
+ * plugin stays dormant instead of blocking the whole dsh-pouch bundle. The
+ * same mechanism powers the settings-GUI master switches (borrowed from
+ * dsh-skills-mcp-manager): `enabled` tears the composition (routes + MCP
+ * fibers) up and down live, `announceToAgent` toggles the model-facing
+ * system-prompt announcement — both editable from the settings GUI through
+ * the official settings provider, persisted in its user document.
  */
+import z from "@deepseek-ai/schemastery";
 import { Store, globalStorePath, projectStorePath } from "./store.js";
 import { Orchestrator } from "./orchestrator.js";
 import { computeSnapshot } from "./status.js";
@@ -24,8 +30,156 @@ import { existsSync, readFileSync } from "node:fs";
 /** Cordis plugin name used by loader diagnostics. */
 export const name = "mcp-console";
 
-export function apply(ctx) {
-  ctx.inject(["webServer", "tools"], (scope) => {
+/** Settings namespace the master switches live under (provider contract: [a-z0-9-]). */
+export const MCP_CONSOLE_SETTINGS_NAMESPACE = "mcp-console";
+
+/** Plugin config: master switches, editable from the settings GUI. */
+export const Config = z.object({
+  /** Master switch: routes + MCP fibers + SSE (stores are never touched). */
+  enabled: z.boolean().default(true),
+  /** Register the model-facing system-prompt announcement. */
+  announceToAgent: z.boolean().default(true),
+});
+
+/** Resolve a raw config value (any shape) onto the switch defaults. */
+export function resolveConfig(value) {
+  return {
+    enabled: value?.enabled !== false,
+    announceToAgent: value?.announceToAgent !== false,
+  };
+}
+
+/**
+ * Register this optional settings consumer on both the current provider API
+ * (`settings.installSection`, dsh-settings >= 0.1.2) and the pre-0.1.2
+ * `register` surface used by older hosts/tests. Same helper as the sibling
+ * pouch plugins — kept verbatim so behavior cannot drift between packages.
+ */
+function installSettingsSection(ctx, ns, schema, entry, hooks) {
+  ctx.inject(["settings"], (settingsCtx) => {
+    const settings = settingsCtx.settings;
+    if (typeof settings?.installSection === "function") {
+      settings.installSection(ctx, ns, schema, entry, hooks);
+      return;
+    }
+    if (typeof settings?.register !== "function") return;
+    const scope = settings.register(ns, schema, {
+      base: entry,
+      ...(hooks.validate === void 0 ? {} : { validate: hooks.validate }),
+    });
+    hooks.setSource(() => scope.get());
+    settingsCtx.effect?.(() => () => {
+      if (ctx.fiber?.state === 4 || ctx.fiber?.state === 5) return;
+      hooks.setSource(() => entry);
+      hooks.onChange();
+    });
+    hooks.onChange();
+    scope.watch(() => {
+      if (ctx.fiber?.state === 4 || ctx.fiber?.state === 5) return;
+      hooks.onChange();
+    });
+  });
+}
+
+/**
+ * Model-facing announcement (borrowed from dsh-skills-mcp-manager): tells
+ * every agent the console exists, so MCP-management requests land in the
+ * settings page instead of hand-edited config files.
+ */
+const SYSTEM_PROMPT_GUIDANCE =
+  "本机已安装 MCP 控制台插件(dsh-plugin-mcp-console):DSH Web 设置页「MCP 服务器」分区可管理全部 MCP 服务器——" +
+  "新增/编辑/删除、启用/停用、逐工具开关、mcpServers JSON 导入、连接测试。启用的服务器经官方 " +
+  "@deepseek-ai/dsh-mcp-client 真实连接,工具名为 mcp__<服务器名>__<工具名>;被逐工具停用的工具仍会出现在工具" +
+  "列表中,但调用会被拒绝并提示去设置页开启。配置由插件持久化在 ~/.dsh/dsh-mcp.json,无需也不应手改 " +
+  "cordis.patch.yml。用户提到「MCP 服务器 / MCP 管理 / 导入 MCP / 测试 MCP 连接」时,引导其到设置页的 " +
+  "「MCP 服务器」分区操作。";
+
+/** System-prompt band this announcement sits in (after plugin guidance basics). */
+const ANNOUNCEMENT_ORDER = 160;
+
+export function apply(ctx, config) {
+  const entry = resolveConfig(config);
+  let current = () => entry;
+
+  /** Live surfaces, each an inject fiber that can be torn down and rebuilt. */
+  let compositionFiber = null;
+  let announcementFiber = null;
+  /** Serializes surface switches behind in-flight disposals (rapid toggles). */
+  let syncChain = Promise.resolve();
+  let booted = false;
+
+  function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+
+  function warn(error) {
+    ctx.logger.warn(`mcp-console: settings sync failed: ${errorMessage(error)}`);
+  }
+
+  async function quietDispose(fiber) {
+    try {
+      await fiber.dispose();
+    } catch {
+      // unload races are reaped by context teardown
+    }
+  }
+
+  /**
+   * Converge the live surfaces onto the resolved switches. All decisions and
+   * creations happen synchronously BEFORE the first await: a paused step must
+   * never re-read the shared fiber slots after resuming (a later step may
+   * have rebuilt them meanwhile), so disposals run from captured locals last.
+   */
+  async function syncStep() {
+    const value = resolveConfig(current());
+    const wantAnnouncement = value.enabled && value.announceToAgent;
+    const toDispose = [];
+    if (wantAnnouncement && !announcementFiber) {
+      announcementFiber = ctx.inject(["systemPrompt"], (scope) => {
+        scope.systemPrompt.section({
+          name: "plugin:mcp-console",
+          order: ANNOUNCEMENT_ORDER,
+          text: SYSTEM_PROMPT_GUIDANCE,
+        });
+      });
+    } else if (!wantAnnouncement && announcementFiber) {
+      toDispose.push(announcementFiber);
+      announcementFiber = null;
+    }
+    if (value.enabled && !compositionFiber) {
+      compositionFiber = ctx.inject(["webServer", "tools"], buildComposition);
+    } else if (!value.enabled && compositionFiber) {
+      toDispose.push(compositionFiber);
+      compositionFiber = null;
+    }
+    for (const fiber of toDispose) {
+      await quietDispose(fiber);
+    }
+  }
+
+  /**
+   * The first pass runs synchronously up to its first await (surface
+   * creation), so the composition exists by the time apply() returns even
+   * when the pre-0.1.2 settings helper fires onChange during registration.
+   * Later passes serialize fully behind the previous step's disposals, so a
+   * rapid off/on never overlaps two live compositions on one route prefix.
+   */
+  function sync() {
+    if (!booted) {
+      booted = true;
+      syncChain = Promise.resolve(syncStep()).catch(warn);
+      return;
+    }
+    syncChain = syncChain.then(syncStep).catch(warn);
+  }
+
+  /**
+   * The console's whole host-side surface: HTTP API + SSE, the per-tool
+   * guard, status observation and the fiber ledger. Everything is created
+   * from the injected scope, so disposing the inject fiber tears it all
+   * down (routes closed, every MCP fiber disposed, guard lifted).
+   */
+  function buildComposition(scope) {
     const globalStore = new Store(globalStorePath());
     const orchestrator = new Orchestrator(scope, { globalStore, onChange: () => notify() });
 
@@ -61,7 +215,11 @@ export function apply(ctx) {
       // 容错降级：保持 global-only
     }
 
-    const routes = registerRoutes(scope, { orchestrator, uiStore: globalStore });
+    const routes = registerRoutes(scope, {
+      orchestrator,
+      uiStore: globalStore,
+      getPluginConfig: () => resolveConfig(current()),
+    });
     const notify = () => routes.notify();
 
     // Per-tool disable (mcp-manager-gui-spec §3.4): a plain-context guard
@@ -96,7 +254,18 @@ export function apply(ctx) {
         routes.dispose();
       };
     }, "mcp-console: composition");
+  }
+
+  // Registered AFTER the surface state exists: the pre-0.1.2 helper fires
+  // onChange synchronously during registration, which must find sync() ready.
+  installSettingsSection(ctx, MCP_CONSOLE_SETTINGS_NAMESPACE, Config, entry, {
+    setSource: (source) => {
+      current = source;
+    },
+    onChange: () => sync(),
   });
+
+  sync();
 }
 
 export { Store, globalStorePath, projectStorePath } from "./store.js";

package/lib/orchestrator.js

@@ -42,6 +42,12 @@ export const FiberState = {
 /** Official initial sync window (default toolCallTimeoutMs) plus slack. */
 export const CONNECT_GRACE_MS = 75000;
 
+/**
+ * Hard budget for one side-fiber probe (ms). Generous vs the official
+ * initial-sync window: a stdio server may need a cold npx/uvx download.
+ */
+export const PROBE_TIMEOUT_MS = 15000;
+
 /** Error with a stable machine-readable code mapped to an HTTP status. */
 export class ConsoleError extends Error {
   /**
@@ -182,6 +188,15 @@ export class Orchestrator {
   toolsOf(name, currentNames) {
     const current = currentNames ?? this.toolNamesSnapshot();
     const entry = this.ledger.get(name);
+    return this.attributeTools(name, current, entry ? entry.toolNames : new Set());
+  }
+
+  /**
+   * Attribute live tool names to one server from a registry snapshot plus a
+   * load-time diff set (prefix first, then unclaimed diff names). Shared by
+   * the snapshot path and the side-fiber probe, which owns no ledger entry.
+   */
+  attributeTools(name, current, captured) {
     const prefix = `mcp__${name}__`;
     const foreignPrefixes = [];
     for (const other of this.liveServerNames()) {
@@ -193,7 +208,7 @@ export class Orchestrator {
         names.push(toolName);
         continue;
       }
-      if (!entry || !entry.toolNames.has(toolName)) continue;
+      if (!captured.has(toolName)) continue;
       if (foreignPrefixes.some((foreign) => toolName.startsWith(foreign))) continue;
       names.push(toolName);
     }
@@ -446,6 +461,88 @@ export class Orchestrator {
     });
   }
 
+  /**
+   * Side-fiber connectivity probe ("Test connection", borrowed from
+   * dsh-skills-mcp-manager): load ONE throwaway official-client fiber with
+   * `failOnStartupError: true`, await its startup handshake, count the tools
+   * it registered, then always dispose it. Zero MCP protocol code — the
+   * handshake itself belongs to the official client, so the console's red
+   * line holds.
+   *
+   * A server whose fiber is currently live cannot be re-probed (the official
+   * client reserves the serverName namespace per module instance); for those
+   * the probe honestly reports the live status instead (`live: true`).
+   *
+   * Serialized through the mutation chain: the probe owns a real fiber and
+   * must never race a load/dispose of the same namespace.
+   *
+   * @param {string} name stored server name
+   * @param {object} [options]
+   * @param {number} [options.timeoutMs] hard probe budget (default 15s)
+   * @returns {Promise<{ok: boolean, live: boolean, toolCount: number, latencyMs: number|null, error: string|null}>}
+   */
+  probe(name, { timeoutMs = PROBE_TIMEOUT_MS } = {}) {
+    return this.run(async () => {
+      const stored = this.storedServers().get(name);
+      if (!stored) throw new ConsoleError("not_found", `unknown server "${name}"`);
+      const { config, error } = validateServerConfig(stored);
+      if (error) {
+        return { ok: false, live: false, toolCount: 0, latencyMs: 0, error };
+      }
+      const entry = this.ledger.get(name);
+      if (entry && entry.fiber && entry.fiber.state !== FiberState.DISPOSED) {
+        // Namespace reserved by the live fiber: report, do not collide.
+        const tools = this.toolsOf(name);
+        const ok = !entry.error && entry.fiber.state === FiberState.ACTIVE && tools.length > 0;
+        return {
+          ok,
+          live: true,
+          toolCount: tools.length,
+          latencyMs: null,
+          error: ok ? null : (entry.error ?? "live but no tools registered"),
+        };
+      }
+      const started = Date.now();
+      let fiber = null;
+      let timer = null;
+      try {
+        if (!this.mcpClient) this.mcpClient = await resolveMcpClient();
+        // force failOnStartupError: the probe must hear about a failed handshake
+        const probeConfig = { ...toClientConfig(config), failOnStartupError: true };
+        const before = this.toolNamesSnapshot();
+        fiber = this.ctx.plugin(this.mcpClient, probeConfig);
+        await new Promise((resolve, reject) => {
+          timer = setTimeout(
+            () => reject(new Error(`probe timed out after ${timeoutMs}ms`)),
+            timeoutMs,
+          );
+          Promise.resolve(fiber).then(resolve, reject);
+        });
+        const after = this.toolNamesSnapshot();
+        const captured = new Set([...after].filter((toolName) => !before.has(toolName)));
+        const toolCount = this.attributeTools(name, after, captured).length;
+        return { ok: true, live: false, toolCount, latencyMs: Date.now() - started, error: null };
+      } catch (probeError) {
+        return {
+          ok: false,
+          live: false,
+          toolCount: 0,
+          latencyMs: Date.now() - started,
+          error: errorMessage(probeError),
+        };
+      } finally {
+        if (timer) clearTimeout(timer);
+        if (fiber && fiber.state !== FiberState.DISPOSED) {
+          try {
+            await fiber.dispose();
+          } catch {
+            // probe already reported; context teardown reaps the rest
+          }
+        }
+      }
+    });
+  }
+
   /**
    * Panel refresh (mcp-manager-gui-spec §3.1): re-examine health and tool
    * lists. Managed servers that read as failed (startup error, or connected

package/lib/routes.js

@@ -12,6 +12,7 @@
  * | POST   | /servers/:name/enable       | enable + assemble                  |
  * | POST   | /servers/:name/disable      | dispose (config kept)              |
  * | POST   | /servers/:name/reconnect    | fiber.restart()                    |
+ * | POST   | /servers/:name/probe        | side-fiber connectivity test       |
  * | POST   | /import                     | mcpServers JSON import             |
  * | GET    | /events                     | SSE status stream                  |
  * | GET    | /config                     | UI config (non-secret)             |
@@ -20,6 +21,10 @@
  * Loopback fence: every mutating and secret-bearing route answers 403 to
  * non-loopback callers; GET /config (UI placement only) is open so a LAN
  * browser can at least read placement while the data routes stay local.
+ * "Loopback" is four checks at once (hardened after dsh-skills-mcp-manager):
+ * a loopback socket peer, a Host header naming a loopback origin (DNS
+ * rebinding fence), no `sec-fetch-site: cross-site` browser marker, and —
+ * when an Origin header is present — an Origin matching the Host.
  */
 import { computeSnapshot } from "./status.js";
 import { ConsoleError } from "./orchestrator.js";
@@ -35,6 +40,9 @@ const STATUS_BY_CODE = { invalid: 400, conflict: 409, not_found: 404, internal:
 
 const LOOPBACK_ADDRESSES = new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1"]);
 
+/** Host header hostnames accepted as loopback (IPv6 keeps its brackets). */
+const LOOPBACK_HOSTNAMES = new Set(["127.0.0.1", "localhost", "[::1]"]);
+
 /**
  * Register the API on the webserver.
  *
@@ -42,9 +50,11 @@ const LOOPBACK_ADDRESSES = new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1"]);
  * @param {object} services
  * @param {import("./orchestrator.js").Orchestrator} services.orchestrator
  * @param {import("./store.js").Store} services.uiStore store holding the `ui` section
+ * @param {() => {enabled: boolean, announceToAgent: boolean}} [services.getPluginConfig]
+ *        resolved master switches (settings-GUI backed), surfaced in /health
  * @returns {{ dispose: () => void, notify: () => void }} route handle
  */
-export function registerRoutes(ctx, { orchestrator, uiStore }) {
+export function registerRoutes(ctx, { orchestrator, uiStore, getPluginConfig }) {
   const sseClients = new Set();
   let heartbeat = null;
   let notifyTimer = null;
@@ -120,6 +130,7 @@ export function registerRoutes(ctx, { orchestrator, uiStore }) {
       respond(res, 200, {
         ok: true,
         plugin: "mcp-console",
+        config: getPluginConfig ? getPluginConfig() : null,
         globalStore: orchestrator.globalStore.path,
         projectStore: orchestrator.projectStore?.path ?? null,
         managed: [...orchestrator.ledger.keys()].sort(),
@@ -219,6 +230,7 @@ export function registerRoutes(ctx, { orchestrator, uiStore }) {
     if (action === "enable") respond(res, 200, await orchestrator.setEnabled(name, true));
     else if (action === "disable") respond(res, 200, await orchestrator.setEnabled(name, false));
     else if (action === "reconnect") respond(res, 200, await orchestrator.reconnect(name));
+    else if (action === "probe") respond(res, 200, await orchestrator.probe(name));
     else respond(res, 404, { error: { code: "not_found", message: `unknown action "${action}"` } });
   }
 
@@ -256,9 +268,43 @@ export function registerRoutes(ctx, { orchestrator, uiStore }) {
   return { dispose, notify };
 }
 
-function isLoopback(req) {
+/**
+ * Loopback fence, four layers deep (borrowed from dsh-skills-mcp-manager):
+ *  1. the socket peer is a loopback address;
+ *  2. the Host header names a loopback origin — a DNS-rebindable name
+ *     (e.g. attacker.example) resolves publicly but the browser sends it in
+ *     Host; rejecting non-loopback Hosts closes that hole;
+ *  3. no `sec-fetch-site: cross-site` marker (browsers always send it on
+ *     cross-site fetches; non-browser clients simply omit it);
+ *  4. when an Origin is present it must match the Host (same-origin) —
+ *     Origin-less clients (curl, EventSource in older stacks) pass.
+ *
+ * @param {import("node:http").IncomingMessage} req
+ */
+export function isLoopback(req) {
   const address = req?.socket?.remoteAddress;
-  return typeof address === "string" && LOOPBACK_ADDRESSES.has(address);
+  if (typeof address !== "string" || !LOOPBACK_ADDRESSES.has(address)) return false;
+  const host = req?.headers?.host;
+  if (typeof host !== "string" || host.length === 0) return false;
+  let hostUrl;
+  try {
+    hostUrl = new URL(`http://${host}`);
+  } catch {
+    return false;
+  }
+  if (!LOOPBACK_HOSTNAMES.has(hostUrl.hostname)) return false;
+  if (req.headers["sec-fetch-site"] === "cross-site") return false;
+  const origin = req.headers.origin;
+  if (origin !== undefined) {
+    let originUrl;
+    try {
+      originUrl = new URL(origin);
+    } catch {
+      return false;
+    }
+    if (originUrl.host !== hostUrl.host) return false;
+  }
+  return true;
 }
 
 function respond(res, status, body) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moon16u/dsh-plugin-mcp-console",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Web GUI console for MCP servers: manages the official @deepseek-ai/dsh-mcp-client at runtime — add/edit/enable/disable/reconnect/delete servers, live status, mcpServers JSON import. No MCP protocol code: connection and tool registration are 100% the official client, resolved from the running DSH profile.",
   "type": "module",
   "main": "lib/index.js",
@@ -28,7 +28,6 @@
     "client": {
       "inject": [
         "@deepseek-ai/dsh-client-locale",
-        "@deepseek-ai/dsh-client-runtime",
         "@deepseek-ai/dsh-client-ui-conversation",
         "@deepseek-ai/dsh-client-ui-slots"
       ],
@@ -36,10 +35,12 @@
     }
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-mcp-client": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-mcp-client": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-settings": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-tools": "^0.1.2-rc.1",
+    "@deepseek-ai/schemastery": "^3.18.2"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-mcp-client": {
@@ -48,6 +49,9 @@
     "@deepseek-ai/dsh-host-webserver": {
       "optional": true
     },
+    "@deepseek-ai/dsh-settings": {
+      "optional": true
+    },
     "@deepseek-ai/dsh-tools": {
       "optional": true
     }