dsh-cc-mcp

[!IMPORTANT] Only upgrade to this version when upgrading DSH to 0.1.5-rc.2 or later. It binds to the 0.1.5 host contracts (^0.1.5-rc.2 peer ranges for dsh-subprocess / schemastery) and does not work on older DSH. If your DSH is still 0.1.0-rc.7–0.1.1-rc.2, do not upgrade — stay on v0.1.x. The two lines are mutually exclusive.

Load Claude Code MCP server configs into DeepSeek Harness as runtime-registered tools — no config-row writes, no restarts for config changes.

把 Claude Code 的 MCP 配置(~/.claude.json 的 user / local、各层祖先的 .mcp.json、plugin.json 内联 mcpServers)以运行时注册工具的形式加载进 DSH。

What it does

| Source | Tool namespace | Notes | |---|---|---| | ~/.claude.json (user / local) | mcp__<server>__<tool> | Claude Code's file scopes; local is projects["<key>"], key = git root | | Every ancestor's .mcp.json (project) | mcp__<server>__<tool> | the nearest file wins a name clash | | Plugin root .mcp.json / plugin.json inline | mcp__plugin_<name>_<server>__<tool> | Official CC plugin naming (e.g. mcp__plugin_asana_asana__asana_create_task) |

• Dual-form parsing (shared dsh-cc-loader): accepts both the {"mcpServers": {...}} wrapper (project level / community plugins) and the bare server map (official plugin form).
• Transports: stdio (command) and http (url → streamable-http) register as tools. sse / ws are reported as unsupported (DSH has no such transport) and never crash anything.
• Env secrets stay out of configs: ${NAME} placeholders are kept verbatim in the IR and expanded at runtime from process.env; ${CLAUDE_PLUGIN_ROOT} expands to the plugin directory. Nothing is written to disk.
• Lazy connections: tool schemas register eagerly (the model must see the list), the actual server process connects on first call, and disconnects after idleTimeoutMs without calls. Dead connections reconnect on the next call.
• Hot reload: editing the project .mcp.json rebuilds running sessions' project MCP surface (~1 s).
• Conflict semantics: a server already provided by a preset/host dsh-mcp-client row is skipped by default; "override": true in the server entry forces the project/plugin connection (agent layer shadows upper layers).
• Management panel (/mcp): every server keeps a status row (connected / failed / disabled / provided-by-host) with its tool list. The Web GUI's /mcp command opens a panel over those rows: a failed server shows a Connect button, a connected one can be re-checked, each row opens a detail view with the server's tools, and Disable hides that server from the model until you enable it again. The session's start-up self-check reports failures as auto-dismissing toasts.
• Host MCP rows are listed too (manageHostRows, on by default): the profile's own @deepseek-ai/dsh-mcp-client instances (github, fetch, …) appear with the tools the host really exposes. Acting on them is workspace-scoped and never rewrites the profile config: Disable hides that row's mcp__<server>__* tools for this workspace only (via the platform's tools.restrict({ deny }), lifted again on Enable), and Connect adopts a row that exposes nothing by connecting with that row's own config and registering its tools inside the session scope.

Trust model ⚠️

.mcp.json is executable project content — the same trust as package.json scripts. Installing this plugin enables that. Children run with a scrubbed environment (credential-shaped and stale DSH_* variables dropped), mirroring the official bridge.

Install (dev / local checkout)

# in packages/cc-mcp: install deps (official MCP SDK + shared loader)
npm install

# user patch layer (hot, no bundle reconcile):
# append to ~/.dsh/profiles/<profile>/cordis.patch.yml
- insert:
    - id: cc-mcp
      name: 'dsh-cc-mcp'
      config:
        enableProject: true
        pluginRoots: []          # absolute paths to plugin dirs (future M4 feeds this)
        idleTimeoutMs: 300000
        toolCallTimeoutMs: 60000
        watchProject: true

Windows absolute paths in pluginRoots need file:///? No — these are plain directory paths inside the config, not module specifiers.

Config

| Field | Default | Meaning | |---|---|---| | enableProject | true | read Claude Code's MCP scopes per session (see below) | | pluginRoots | [] | extra plugin directories to scan (.mcp.json + plugin.json) | | idleTimeoutMs | 300000 | idle disconnect (0 = never) | | toolCallTimeoutMs | 60000 | per-call timeout | | watchProject | true | hot-reload the ancestor .mcp.json files and ~/.claude.json | | connectConcurrency | 8 | how many servers may be dialed at once | | claudeJsonPath | '' (→ <homeDir>/.claude.json) | where Claude Code keeps the user/local MCP scopes | | homeDir | os.homedir() | override the home directory ~/.claude.json is read from | | enableManager | true | register the /mcp command and the panel's /cc-mcp route | | manageHostRows | true | list the profile's @deepseek-ai/dsh-mcp-client rows in the panel (disabling one only hides its tools in this workspace) | | statePath | '' (→ <workspace>/.dsh/cc-mcp-state.json) | explicit state-file override; empty keeps decisions per session workspace (machine-wide file only when the session has no workspace) |

Where servers come from

Claude Code has no "project root": it resolves MCP config per scope, and this plugin reads the same ones, in Claude Code's own lookup precedence (enterprise > managed > local > project > user; the two organisation-scoped ones live in system locations this plugin does not read):

| Scope | File | Notes | |---|---|---| | user | ~/.claude.json (top-level mcpServers) | always in play | | local | ~/.claude.json → projects["<key>"].mcpServers | <key> is the git root with forward slashes, or the parent of the session directory outside a repository | | project | every ancestor's .mcp.json, from the session directory up to (not including) the filesystem root | the nearest file wins a name clash | | plugin | pluginRoots (plugin .mcp.json / plugin.json) | namespaced mcp__plugin_<plugin>_<server>__ |

Every row's detail view names the scope and the exact file it was read from. Project-scope servers are default-open here — see dsh-cc-permissions for the one settings key that can still refuse them.

Connections are pooled

One client per (server identity, config), shared by every session in the process — the same idea as Claude Code's process-global MCP clients, which it reconciles by config equality (an unchanged config retains the live client; only a changed one is cleared and re-dialed).

• An unchanged config is never dialed twice. The pooled client and the tool list it already fetched are handed to the next session as-is, so the tools register without spawning anything and /mcp opens with every row already settled instead of filling in one at a time.
• A changed config is a different identity and gets its own fresh dial; the old client closes when it goes idle.
• Servers are dialed connectConcurrency at a time, not one after another — one slow server no longer delays every server behind it.
• A client closes after it has been idle for idleTimeoutMs (default 5 min), when the server drops the connection itself, on a manual Reconnect, and when the plugin unloads (no orphaned child processes).
• One caveat, inherited from Claude Code: the spawn cwd is not part of a server's identity, so a stdio server keeps the working directory of whichever session dialed it first. Only an explicit cwd in the server config distinguishes two otherwise-identical servers.

Management panel

/mcp (bare) opens the panel in the Web GUI; /mcp <anything> prints the text report instead, and the same report is what a headless/CLI session gets.

| Status | Meaning | Panel | |---|---|---| | ready | connected and its tools are visible | ✓ — click to re-check | | error | the connection failed (host rows say whether Connect can adopt it) | Connect button, error text in the detail view | | disabled | disabled in this workspace | Enable button | | skipped | another layer already registers this tool prefix | shown as host-provided, with the visible tools | | checking | a check/connect is in flight | spinner |

| Scope | Where it comes from | Disable does | |---|---|---| | Project | the ancestor .mcp.json files | unregister this plugin's tools for that server | | User / Local | ~/.claude.json (top-level / projects["<key>"]) | same | | Plugin | pluginRoots (plugin .mcp.json / plugin.json) | same, under mcp__plugin_<plugin>_<server>__ | | Host | the profile's dsh-mcp-client rows | hide that row's tools for this workspace only (tools.restrict({ deny }), lifted on Enable) — the profile config is never rewritten |

Connect on a host row that exposes no tools adopts it: this plugin connects with that row's own config and registers the tools inside the session scope, so a row whose own connection failed still gives this workspace working tools.

Decisions are remembered in <workspace>/.dsh/cc-mcp-state.json — per session workspace, i.e. the directory the session was started in ($DSH_HOME/cc-mcp-state.json only for a session with no workspace) — which is the only file this plugin writes; your .mcp.json, the profile config and Claude Code settings are never touched. Add .dsh/ to the project's .gitignore if you do not want to share the choices.

Try the panel locally

A throwaway project config used to exercise the panel end to end (one server that connects, one that fails so Connect has something to do):

{
  "mcpServers": {
    "cc-echo": { "command": "node", "args": ["<repo>/packages/cc-mcp/test/mcp-echo-server.mjs"] },
    "cc-flaky": {
      "command": "node",
      "args": [
        "<repo>/packages/cc-mcp/test/mcp-flaky-server.mjs",
        "<repo>/.cc-mcp-marker"
      ]
    }
  }
}

cc-flaky refuses to start until <repo>/.cc-mcp-marker exists; create it and press Connect to watch the row flip to connected.

Example

<project>/.mcp.json:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
    }
  }
}

Sessions in that project get mcp__github__create_issue etc. on first tool list assembly.

License

MIT — runtime registration pattern ported from dsh-project-mcp-bridge (MIT, © KYinCode); parsing lives in dsh-cc-loader.