@omdp/dsh-connector 0.1.0

package/README.md

@@ -0,0 +1,106 @@
+# @omdp/dsh-connector
+
+一个 DeepSeek Harness (`dsh`) 插件，把 **MCP 服务器** 和 **用户 Skills** 的管理合并到 Web UI 的同一个设置页里（设置页标签：**Connector**）。
+
+- **MCP**：读取/编辑 `profiles/web/cordis.patch.yml` 中的 `mcp-*` 块（结构化表单）。保存后**重启 `dsh` 生效**。
+- **Skills**：列出/查看/编辑/删除 `~/.dsh/skills` 下的 `SKILL.md`。保存**即时生效**（filesystem provider 自动重新发现）。
+
+设计上复用官方两款参考插件的方式：
+- 设置页槽位注册方式参照 [`dsh-mcp-manager`](https://github.com/hyqhyq3/dsh-mcp-manager)（`settings.section` + Package 私有 HTTP API）。
+- Skills 的 frontmatter 解析/序列化参照 [`dsh-skill-manager`](https://github.com/bitterSmilezzz/dsh-skill-manager)。
+
+### SSE(MCP over SSE) 如何处理
+
+本插件**不**内置 SSE 桥接。需要连接走 legacy SSE 协议的 MCP 服务器（如知乎搜索 / 全网搜索）时，仍在 `cordis.patch.yml` 里用 [`mcp-remote`](https://github.com/geelen/mcp-remote) 把 SSE 转成 stdio，本插件只是把它作为一条普通 mcp-remote 配置来可视化编辑。这样避免重造进程管理逻辑——连接本身交给成熟的 mcp-remote。
+
+## 安装
+
+**推荐：本地 `link:` 安装**（避免从 GitHub 直接拉取的网络/TLS 问题）。在
+`profiles/web/package.json` 的 `dependencies` 里加入（或直接编辑）：
+
+```json
+"@omdp/dsh-connector": "link:D:/WorkSpace/omdp/dsh-connector"
+```
+
+然后在该 profile 下重建 lockfile 并建立 junction（`dsh plugin add` 底层就是 pnpm，
+等价于）：
+
+```sh
+cd ~/.dsh/profiles/web
+pnpm install --lockfile-only --offline   # 按 link 依赖重写 lockfile
+```
+
+> `pnpm install` 会为 `link:` 依赖建立 `node_modules/@omdp/dsh-connector` junction
+> 指向 `D:/WorkSpace/omdp/dsh-connector`，插件源码即仓库源码，**改仓库 → 重启 dsh 即生效**。
+
+确保 `dsh.profile.bundles` 里包含 `"@omdp/dsh-connector"`（包内声明了
+`dsh.bundle.patch`，激活行自动生效，无需手动改 `cordis.patch.yml`）。
+
+> 安装前请先**备份** `profiles/web/cordis.patch.yml`。本插件会改写其中的 MCP 块。
+
+### 备选：从 GitHub 远程安装
+
+不想本地 checkout 时，可直接从仓库装（`#path:` 指向子目录）：
+
+```sh
+dsh plugin --profile web add github:XJungit/omdp#path:dsh-connector
+```
+
+pnpm ≥10 默认拒绝运行 git 依赖的构建脚本，首次 `add` 会失败，需在
+`profiles/web/pnpm-workspace.yaml` 加白名单后重试：
+
+```yaml
+allowBuilds:
+  '@omdp/dsh-connector': true
+```
+
+（本插件是纯 JS 零构建，白名单是唯一门槛，无需 `prepare` 脚本。详见官方
+[publish.md](https://github.com/deepseek-ai/deepseek-harness/blob/master/docs/user/develop/basic/publish.md)。）
+
+## 更新
+
+本地 link 模式下**没有"拉取"这一步**：直接 `git pull` 或编辑 `D:/WorkSpace/omdp`，
+然后**重启 `dsh --profile web`** 加载新代码（运行中的进程仍用旧代码）。
+
+## 使用
+
+打开 Web UI 的 **设置 → Connector**：
+
+1. **MCP 服务器** 区：
+   - 列出当前 `cordis.patch.yml` 里的 `mcp-*` 服务器
+   - 「编辑」改名称/传输/URL/命令/参数/Header；「删除」移除；「＋ 添加」新建
+   - 保存后提示**重启 dsh** 才会真正加载新的 MCP server
+2. **Skills** 区：
+   - 列出 `~/.dsh/skills` 下的用户技能
+   - 「编辑」改 frontmatter 与正文；「删除」移除目录；「＋ 新建」创建
+
+## 工作原理
+
+| 组成 | 机制 |
+|---|---|
+| 设置页 | client half 注册 `settings.section` 槽位（"Connector" 页签） |
+| 跨边界调用 | client 用 `fetch('/connector/api/...')`，host 用 `ctx.webServer.register` 接收（安装包走 HTTP） |
+| MCP 持久化 | 文本块级提取并替换 `cordis.patch.yml` 中含 `mcp-` 的 insert 块，**保留 `!!js` 表达式与 env 块原样**（preserve 桶） |
+| Skill 持久化 | 直接读写 `~/.dsh/skills/<name>/SKILL.md` |
+
+## 已知限制
+
+- MCP 改动需**重启 dsh** 才生效（因为 `dsh-mcp-client` 实例是静态加载的）。若想要保存即时生效，需用 `dsh-mcp-manager`（它自行实现 MCP client）。
+- 保存时按 `dsh-mcp-client` 的契约**校验**：`transport` 只能是 `stdio`/`streamable-http`；`serverName` 必须匹配 `[A-Za-z0-9_-]{1,32}`；stdio 的 `command` 必须是单个词且能在 PATH 中找到（或为绝对路径）；streamable-http 的 `url` 必须是合法 http(s)（`!!js` 表达式除外）；命令/URL/参数中不允许控制字符。任何一项不合法，保存会被拒绝（HTTP 400）并提示原因，**不会写入** `cordis.patch.yml`——坏配置永远到不了下次启动。
+- MCP 块解析为结构化提取，复杂嵌套 YAML（如多 env 变量）在表单里以单字段呈现；极复杂配置请直接在 `cordis.patch.yml` 编辑。
+- 不桥接 MCP 的 resources/prompts，只管理 server 配置。
+
+## 安全实践
+
+- **不要在 `cordis.patch.yml` 里写明文 token**。MCP server 需要密钥时，用环境变量引用（`!!js process.env.XXX`），例如：
+  ```yaml
+  env:
+    AUTH_HEADER: !!js ('Bearer ' + process.env.ZHIHU_TOKEN)
+  ```
+  token 明文只存在于 `.env` / 系统环境变量，不落进配置文件（同 `dsh-mcp-manager` 的 `tokenEnv` 理念）。
+- 本插件的 API（`/connector/api/*`）与 DSH GUI 同源，无额外鉴权——仅限本机使用，不要暴露到公网。
+- Skills 内容与 MCP 配置都属于本地敏感数据，改动会直接写入磁盘。
+
+## License
+
+MIT

package/client.js

@@ -0,0 +1,404 @@
+/**
+ * @omdp/dsh-connector — client half.
+ *
+ * Installed-package client bundle: the harness serves this file at
+ * /plugins/<id>/client.js and expects a single window.__ModuleLoader__.load
+ * handoff whose factory receives `require`. We register one unified settings
+ * tab ("Connector") that manages two things in a single page:
+ *   - MCP servers: read/edit the mcp-* block of cordis.patch.yml
+ *   - user skills:  list/view/edit/remove SKILL.md files under ~/.dsh/skills
+ *
+ * It talks to the host half over the Package-private HTTP API the host mounts
+ * on the DSH GUI webserver (/connector/api/*), exactly like
+ * dsh-mcp-manager's client does with fetch — not the dynamic-only host.call.
+ *
+ * @module @omdp/dsh-connector/client
+ */
+
+window.__ModuleLoader__.load({
+  id: '@omdp/dsh-connector',
+  factory: (require) => {
+    var module = { exports: {} }
+    var exports = module.exports
+    Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+    var react = require('react')
+    var createElement = react.createElement
+
+    var css =
+      '.pm_root{display:flex;flex-direction:column;gap:20px;padding:0 24px 24px}' +
+      '.pm_tabs{display:flex;gap:8px;padding:0 24px}' +
+      '.pm_section{display:flex;flex-direction:column;gap:12px}' +
+      '.pm_sectionHead{font-weight:600;font-size:15px}' +
+      '.pm_row{display:flex;flex-direction:column;gap:8px;border:1px solid rgba(128,128,128,.3);border-radius:12px;padding:12px 14px}' +
+      '.pm_rowHead{display:flex;align-items:center;gap:10px}' +
+      '.pm_name{font-weight:600;font-size:14px}' +
+      '.pm_kind{font-size:11px;padding:2px 8px;border-radius:8px;border:1px solid rgba(128,128,128,.4);color:var(--dsw-alias-label-secondary,#888)}' +
+      '.pm_meta{font-size:12px;color:var(--dsw-alias-label-secondary,#888);word-break:break-all}' +
+      '.pm_actions{margin-left:auto;display:flex;gap:8px}' +
+      '.pm_btn{cursor:pointer;font-size:12px;padding:5px 12px;border-radius:8px;border:1px solid rgba(128,128,128,.5);background:transparent;color:inherit}' +
+      '.pm_btn:hover{background:rgba(128,128,128,.12)}' +
+      '.pm_btn:disabled{opacity:.5;cursor:default}' +
+      '.pm_btn.primary{border-color:transparent;background:var(--dsw-alias-interactive-bg-active,#2563eb);color:#fff}' +
+      '.pm_btn.danger{border-color:#c62828;color:#c62828}' +
+      '.pm_err{color:#c62828;font-size:12px}' +
+      '.pm_form{display:grid;grid-template-columns:1fr 1fr;gap:10px}' +
+      '.pm_form label{display:flex;flex-direction:column;gap:4px;font-size:12px}' +
+      '.pm_form input,.pm_form textarea,.pm_form select{font:inherit;font-size:13px;padding:6px 8px;border-radius:8px;border:1px solid rgba(128,128,128,.4);background:transparent;color:inherit}' +
+      '.pm_form .wide{grid-column:1 / -1}' +
+      '.pm_add{border-style:dashed}' +
+      '.pm_hint{font-size:12px;color:var(--dsw-alias-label-secondary,#888)}' +
+      '.pm_textarea{font-family:ui-monospace,Menlo,Consolas,monospace;min-height:140px}'
+
+    if (typeof document !== 'undefined' && document.querySelector('style[data-plugin-css="@omdp/dsh-connector/section"]') === null) {
+      var tag = document.createElement('style')
+      tag.dataset.plugin = '@omdp/dsh-connector'
+      tag.dataset.pluginCss = '@omdp/dsh-connector/section'
+      tag.textContent = css
+      document.head.appendChild(tag)
+    }
+
+    function api(path, options) {
+      return fetch('/connector/api' + path, {
+        headers: { 'Content-Type': 'application/json' },
+        ...options,
+      }).then(function (resp) {
+        return resp.json().catch(function () { return {} })
+      })
+    }
+
+    // Server ids must stay kebab-case under the fixed `mcp-` prefix: the host
+    // parser and dsh-mcp-client both key on it, so the prefix is not optional.
+    var MCP_ID_RE = /^mcp-[a-z0-9]+(?:-[a-z0-9]+)*$/
+
+    function deriveServerId(serverName) {
+      var base = (serverName || 'server').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+      return 'mcp-' + (base || 'server')
+    }
+
+    function field(label, value, onChange) {
+      return createElement('label', { className: 'wide' },
+        label,
+        createElement('input', { value: value || '', onChange: function (e) { onChange(e.target.value) } }),
+      )
+    }
+
+    function selectField(label, value, opts, onChange) {
+      return createElement('label', null,
+        label,
+        createElement('select', { value: value || opts[0], onChange: function (e) { onChange(e.target.value) } },
+          opts.map(function (o) { return createElement('option', { value: o, key: o }, o) }),
+        ),
+      )
+    }
+
+    function ManageTab() {
+      var _a = react.useState('mcp')
+      var tab = _a[0]
+      var setTab = _a[1]
+      var _b = react.useState({ servers: [], exists: true })
+      var mcp = _b[0]
+      var setMcp = _b[1]
+      var _c = react.useState([])
+      var skills = _c[0]
+      var setSkills = _c[1]
+      var _d = react.useState('')
+      var error = _d[0]
+      var setError = _d[1]
+      var _e = react.useState(false)
+      var busy = _e[0]
+      var setBusy = _e[1]
+
+      function refresh() {
+        setBusy(true)
+        setError('')
+        Promise.all([api('/mcp', { method: 'GET' }), api('/skills', { method: 'GET' })]).then(function (r) {
+          setMcp(r[0])
+          setSkills(r[1].skills || [])
+        }).catch(function (e) {
+          setError(String(e))
+        }).finally(function () { setBusy(false) })
+      }
+      react.useEffect(function () { refresh() }, [])
+
+      return createElement('div', { className: 'pm_root' },
+        createElement('div', { className: 'pm_tabs' },
+          createElement('button', { className: 'pm_btn' + (tab === 'mcp' ? ' primary' : ''), onClick: function () { setTab('mcp') } }, 'MCP 服务器 MCP Servers'),
+          createElement('button', { className: 'pm_btn' + (tab === 'skills' ? ' primary' : ''), onClick: function () { setTab('skills') } }, 'Skills 技能'),
+        ),
+        error ? createElement('div', { className: 'pm_err' }, error) : null,
+        tab === 'mcp'
+          ? createElement(McpPane, { mcp: mcp, busy: busy, onChanged: refresh })
+          : createElement(SkillPane, { skills: skills, busy: busy, onChanged: refresh }),
+      )
+    }
+
+    function McpPane(props) {
+      var _a = react.useState(null)
+      var editing = _a[0]
+      var setEditing = _a[1]
+      var _b = react.useState('')
+      var err = _b[0]
+      var setErr = _b[1]
+
+      function save(server) {
+        api('/mcp', {
+          method: 'POST',
+          body: JSON.stringify({ servers: props.mcp.servers.map(function (s) { return s.id === server.id ? server : s }).concat(props.mcp.servers.some(function (s) { return s.id === server.id }) ? [] : [server]) }),
+        }).then(function (r) {
+          if (r && r.error) { setErr(r.error); return }
+          setErr('')
+          setEditing(null)
+          props.onChanged()
+        })
+      }
+      function remove(id) {
+        api('/mcp', {
+          method: 'POST',
+          body: JSON.stringify({ servers: props.mcp.servers.filter(function (s) { return s.id !== id }) }),
+        }).then(function (r) {
+          if (r && r.error) { setErr(r.error); return }
+          setErr('')
+          props.onChanged()
+        })
+      }
+
+      var rows = props.mcp.servers.map(function (s) {
+        return createElement('div', { className: 'pm_row', key: s.id },
+          createElement('div', { className: 'pm_rowHead' },
+            createElement('span', { className: 'pm_name' }, s.name || s.id),
+            createElement('span', { className: 'pm_kind' }, s.transport || 'stdio'),
+          ),
+          createElement('div', { className: 'pm_meta' }, s.url ? 'url: ' + s.url : (s.command ? 'cmd: ' + s.command : '')),
+          createElement('div', { className: 'pm_actions' },
+            createElement('button', { className: 'pm_btn', onClick: function () { setEditing(s) } }, '编辑 Edit'),
+            createElement('button', { className: 'pm_btn danger', onClick: function () { remove(s.id) } }, '删除 Delete'),
+          ),
+        )
+      })
+
+      return createElement('div', { className: 'pm_section' },
+        createElement('div', { className: 'pm_sectionHead' }, 'MCP 服务器 MCP Servers'),
+        err ? createElement('div', { className: 'pm_err' }, err) : null,
+        createElement('div', { className: 'pm_hint' },
+          props.mcp.exists ? '编辑 profiles/web/cordis.patch.yml 中的 mcp-* 块。保存后重启 dsh 生效。Edit the mcp-* block in cordis.patch.yml; restart dsh to apply.' : '未找到 cordis.patch.yml。cordis.patch.yml not found.'),
+        rows,
+        editing === null
+          ? createElement('button', { className: 'pm_btn pm_add', onClick: function () { setEditing({ id: 'mcp-new', customId: '', name: '', transport: 'stdio', serverName: '', url: '', command: '', args: '' }) } }, '＋ 添加 MCP 服务器 Add MCP Server')
+          : createElement(ServerForm, { value: editing, onSave: save, onCancel: function () { setEditing(null) } }),
+      )
+    }
+
+    function ServerForm(props) {
+      // Normalize a block-sequence `args` (parsed into argsLines[]) into the
+      // space-separated string the form edits, and drop argsLines so a save
+      // always goes through the `args` field (renderServer re-emits it as an
+      // inline array). Without this, editing a server whose args were written
+      // as a YAML block sequence shows an empty Args box, and clearing the
+      // field can't remove the old argsLines.
+      function initForm(value) {
+        var a = value.args || ''
+        if (!a && value.argsLines && value.argsLines.length) {
+          a = value.argsLines.join(' ')
+        }
+        var next = Object.assign({}, value, { args: a })
+        delete next.argsLines
+        return next
+      }
+      var _a = react.useState(initForm(props.value))
+      var v = _a[0]
+      var setV = _a[1]
+      var _b = react.useState('')
+      var err = _b[0]
+      var setErr = _b[1]
+      function set(key) { return function (val) { var next = Object.assign({}, v); next[key] = val; setV(next) } }
+
+      var isNew = v.id === 'mcp-new'
+      var derivedId = deriveServerId(v.serverName || v.name)
+      var idValue = isNew ? (v.customId !== undefined && v.customId !== '' ? v.customId : derivedId) : v.id
+
+      // dsh-mcp-client's own serverName contract; the harness rejects anything
+      // else at boot, so it must be rejected here.
+      var SERVER_NAME_RE = /^[A-Za-z0-9_-]{1,32}$/
+      var CONTROL_CHARS = /[\x00-\x1f\x7f]/
+      var TRANSPORTS = { stdio: true, 'streamable-http': true }
+
+      function looksLikeExpression(value) {
+        var text = (value || '').trim()
+        return text.indexOf('!!js') === 0 || text.indexOf('process.env') !== -1 || text.indexOf('&&') !== -1 || text.indexOf('(') === 0
+      }
+
+      function submit() {
+        var problems = []
+        var t = v.transport || 'stdio'
+        var name = (v.serverName || '').trim()
+        if (!name) problems.push('serverName 必填 Name is required')
+        else if (!SERVER_NAME_RE.test(name)) problems.push('serverName 必须为 1-32 位 [A-Za-z0-9_-] Name must match [A-Za-z0-9_-]{1,32}')
+        if (!TRANSPORTS[t]) problems.push('未知传输类型 Unknown transport')
+        if (t === 'stdio') {
+          var command = (v.command || '').trim()
+          if (!command) problems.push('stdio 传输必须填 Command Command is required for stdio')
+          else if (/\s|['"]/.test(command)) problems.push('Command 必须是单个词，不能有空格或引号 Command must be a single token (no spaces/quotes)')
+          else if (CONTROL_CHARS.test(command)) problems.push('Command 不能含控制字符 Command must not contain control characters')
+          var argsText = (v.args || '').trim()
+          if (argsText && CONTROL_CHARS.test(argsText)) problems.push('Args 不能含控制字符 Args must not contain control characters')
+        }
+        if (t === 'streamable-http') {
+          var url = (v.url || '').trim()
+          if (!url) problems.push('streamable-http 传输必须填 URL URL is required for streamable-http')
+          else if (!looksLikeExpression(url)) {
+            try {
+              var parsed = new URL(url)
+              if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') problems.push('URL 必须是 http(s) URL must be http(s)')
+            } catch (e) {
+              problems.push('URL 无效 Invalid URL')
+            }
+          }
+        }
+        if (isNew) {
+          var custom = (v.customId || '').trim()
+          if (custom && !MCP_ID_RE.test(custom)) problems.push('ID 必须以 mcp- 开头且为小写 kebab-case，如 mcp-github ID must be mcp-<kebab-case>')
+        }
+        if (problems.length) { setErr(problems.join('；')); return }
+        setErr('')
+        // Never send a stale argsLines back: renderServer prefers argsLines over
+        // args, so a leftover array would clobber the edited/cleared args field.
+        var next = Object.assign({}, v)
+        delete next.argsLines
+        if (isNew) {
+          var id = MCP_ID_RE.test(custom) ? custom : derivedId
+          props.onSave(Object.assign({}, next, { id: id, name: v.serverName || v.name }))
+        } else {
+          props.onSave(Object.assign({}, next, { name: v.serverName || v.name }))
+        }
+      }
+
+      return createElement('div', { className: 'pm_row' },
+        err ? createElement('div', { className: 'pm_err' }, err) : null,
+        createElement('div', { className: 'pm_form' },
+          field('名称 (serverName) Name', v.serverName, set('serverName')),
+          selectField('传输 Transport', v.transport, ['stdio', 'streamable-http'], set('transport')),
+          field('URL (http)', v.url, set('url')),
+          field('命令 (stdio) Command', v.command, set('command')),
+          field('参数 (空格分隔) Args', v.args, set('args')),
+          field('Header', v.header, set('header')),
+          isNew
+            ? createElement('label', { className: 'wide' },
+                'ID (默认自动生成，前缀固定 mcp- 如 mcp-github) ID (auto, fixed mcp- prefix)',
+                createElement('input', {
+                  value: idValue,
+                  onChange: function (e) { set('customId')(e.target.value) },
+                }),
+              )
+            : createElement('div', { className: 'pm_meta wide' }, 'id: ' + v.id),
+        ),
+        createElement('div', { className: 'pm_actions' },
+          createElement('button', { className: 'pm_btn primary', onClick: submit }, '保存 Save'),
+          createElement('button', { className: 'pm_btn', onClick: props.onCancel }, '取消 Cancel'),
+        ),
+      )
+    }
+
+    function SkillPane(props) {
+      var _a = react.useState(null)
+      var editing = _a[0]
+      var setEditing = _a[1]
+      var _b = react.useState('')
+      var err = _b[0]
+      var setErr = _b[1]
+
+      function open(name) {
+        api('/skills/' + encodeURIComponent(name), { method: 'GET' }).then(function (skill) {
+          if (skill && skill.error) { setErr(skill.error); return }
+          setErr('')
+          setEditing(skill)
+        })
+      }
+      function save(skill) {
+        api('/skills', { method: 'PUT', body: JSON.stringify(skill) }).then(function (r) {
+          if (r && r.error) { setErr(r.error); return }
+          setErr('')
+          setEditing(null)
+          props.onChanged()
+        })
+      }
+      function remove(name) {
+        api('/skills/' + encodeURIComponent(name), { method: 'DELETE' }).then(function (r) {
+          if (r && r.error) { setErr(r.error); return }
+          setErr('')
+          props.onChanged()
+        })
+      }
+
+      var rows = props.skills.map(function (s) {
+        return createElement('div', { className: 'pm_row', key: s.name },
+          createElement('div', { className: 'pm_rowHead' },
+            createElement('span', { className: 'pm_name' }, s.name),
+          ),
+          createElement('div', { className: 'pm_meta' }, s.description || ''),
+          createElement('div', { className: 'pm_actions' },
+            createElement('button', { className: 'pm_btn', onClick: function () { open(s.name) } }, '编辑 Edit'),
+            createElement('button', { className: 'pm_btn danger', onClick: function () { remove(s.name) } }, '删除 Delete'),
+          ),
+        )
+      })
+
+      return createElement('div', { className: 'pm_section' },
+        createElement('div', { className: 'pm_sectionHead' }, '用户 Skills (~/.dsh/skills) User Skills'),
+        err ? createElement('div', { className: 'pm_err' }, err) : null,
+        createElement('div', { className: 'pm_hint' }, '读写用户技能目录，保存即生效（skill catalog 自动刷新）。Read/write user skills; saved changes take effect immediately.'),
+        rows,
+        editing === null
+          ? createElement('button', { className: 'pm_btn pm_add', onClick: function () { setEditing({ name: '', description: '', content: '' }) } }, '＋ 新建 Skill New Skill')
+          : createElement(SkillForm, { value: editing, onSave: save, onCancel: function () { setEditing(null) } }),
+      )
+    }
+
+    function SkillForm(props) {
+      var _a = react.useState(props.value)
+      var v = _a[0]
+      var setV = _a[1]
+      var _b = react.useState('')
+      var err = _b[0]
+      var setErr = _b[1]
+      function set(key) { return function (val) { var next = Object.assign({}, v); next[key] = val; setV(next) } }
+
+      function submit() {
+        var name = (v.name || '').trim()
+        if (!name) { setErr('名称必填 Name is required'); return }
+        if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name)) { setErr('名称必须是小写 kebab-case，如 my-skill Name must be kebab-case'); return }
+        setErr('')
+        props.onSave(Object.assign({}, v, { name: name }))
+      }
+
+      return createElement('div', { className: 'pm_row' },
+        err ? createElement('div', { className: 'pm_err' }, err) : null,
+        createElement('div', { className: 'pm_form' },
+          field('名称 (kebab-case) Name', v.name, set('name')),
+          field('描述 Description', v.description, set('description')),
+          createElement('label', { className: 'wide' },
+            'SKILL.md 内容 (Markdown) Content',
+            createElement('textarea', { className: 'pm_textarea wide', value: v.content || '', onChange: function (e) { var next = Object.assign({}, v); next.content = e.target.value; setV(next) } }),
+          ),
+        ),
+        createElement('div', { className: 'pm_actions' },
+          createElement('button', { className: 'pm_btn primary', onClick: submit }, '保存 Save'),
+          createElement('button', { className: 'pm_btn', onClick: props.onCancel }, '取消 Cancel'),
+        ),
+      )
+    }
+
+    function apply(ctx) {
+      var slots = ctx.get('slots')
+      if (slots === undefined) return
+      slots.inject('settings.section', function () {
+        return slots.register(
+          { name: 'settings.section', id: 'connector', order: 55, label: 'Connector 连接器' },
+          ManageTab,
+        )
+      })
+    }
+
+    exports.apply = apply
+    return module.exports
+  },
+})

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# @omdp/dsh-connector bundle patch: activates the plugin row in any profile
+# that installs this package (via `dsh plugin --profile <name> add ...`).
+# The user's own cordis.patch.yml may still override or disable this row by id.
+- insert:
+    - id: connector
+      name: '@omdp/dsh-connector'

package/index.js

@@ -0,0 +1,654 @@
+/**
+ * dsh-connector — host half (installed-package plugin).
+ *
+ * Manages two deployment assets from one unified Web UI (see client.js):
+ *
+ *   1. MCP servers — the `mcp-*` entries inside the profile's cordis.patch.yml
+ *   2. User skills   — the `<dshHome>/skills` directory (~/.dsh/skills)
+ *
+ * The client half calls this host half over a Package-private HTTP API mounted
+ * on the DSH GUI webserver at /connector/api/*. (For an installed package
+ * the Client→Host boundary is HTTP, not the dynamic-only host.call.)
+ *
+ * MCP rewrite safety: cordis.patch.yml contains `!!js` expressions, env blocks
+ * and hand-written comments. A strict YAML parser would reject or mangle them.
+ * So we locate the INSERT BLOCK that contains `mcp-` ids and replace ONLY the
+ * `    - id: mcp-*` server entries inside it, preserving every other line
+ * (header comments, the trailing connector row, and each server's env /
+ * header / arbitrary nested keys) verbatim through a `preserve` bucket.
+ *
+ * @module dsh-connector
+ */
+
+import { readFile, writeFile, mkdir, readdir, rm, rename } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import { homedir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml'
+
+const API_PREFIX = '/connector/api'
+const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+// Server ids are keys for the mcp-* block (and dsh-mcp-client instances):
+// kebab-case under a fixed `mcp-` prefix, which parseMcpServers also requires.
+const MCP_ID_RE = /^mcp-[a-z0-9]+(?:-[a-z0-9]+)*$/
+// dsh-mcp-client's own serverName contract (lib/types/index.js SERVER_NAME_PATTERN).
+const SERVER_NAME_RE = /^[A-Za-z0-9_-]{1,32}$/
+const TRANSPORTS = new Set(['stdio', 'streamable-http'])
+// Anything that would break YAML/JSON transport, a cmd command line, or the
+// patch file itself (NUL, control chars). Tab/newline are already rejected by
+// the single-token rules; this catches the rest defensively.
+const CONTROL_CHARS = /[\x00-\x1f\x7f]/
+export const inject = ['webServer']
+export { validateServer, commandResolvable }
+
+function resolveHome() {
+  const fromEnv = process.env.DSH_HOME
+  return fromEnv !== undefined && fromEnv.trim().length > 0
+    ? fromEnv.trim()
+    : join(homedir(), '.dsh')
+}
+
+function patchPath() {
+  return join(resolveHome(), 'profiles', 'web', 'cordis.patch.yml')
+}
+
+function skillsRoot() {
+  return join(resolveHome(), 'skills')
+}
+
+/* ───────────────────────── MCP block handling ────────────────────────────
+ * The MCP servers live inside one top-level `- insert:` list. We find the
+ * insert block that actually contains `mcp-` ids (the first such one), split
+ * the file into [head, mcpBlock, tail], and only rewrite server entries inside
+ * mcpBlock. head keeps the header comments; tail keeps every later insert
+ * (including our own connector row).
+ * ────────────────────────────────────────────────────────────────────────── */
+
+function findMcpBlock(text) {
+  const re = /\n- insert:/g
+  let m
+  const starts = []
+  while ((m = re.exec(text)) !== null) starts.push(m.index)
+  for (const start of starts) {
+    const blockStart = start + 1 // after the leading \n
+    // locate the next insert (or EOF) as block end
+    let end = text.length
+    re.lastIndex = blockStart
+    const next = re.exec(text)
+    if (next) end = next.index + 1
+    re.lastIndex = 0
+    const blockText = text.slice(blockStart, end)
+    if (/\n\s*- id:\s*["']?mcp-/.test(blockText)) {
+      return { head: text.slice(0, blockStart), blockText, tail: text.slice(end) }
+    }
+  }
+  return null
+}
+
+function stripQuotes(v) {
+  if ((v.startsWith("'") && v.endsWith("'")) || (v.startsWith('"') && v.endsWith('"'))) {
+    return v.slice(1, -1)
+  }
+  return v
+}
+
+// Extract the bare scalar from a YAML block-sequence item line like
+// `  - '--transport'` -> `--transport`. Handles quoted and unquoted values.
+function stripListScalar(line) {
+  const m = line.match(/^\s*-\s*(.*)$/)
+  if (!m) return line.trim()
+  return stripQuotes(m[1].trim())
+}
+
+const KNOWN_KEYS = new Set(['transport', 'serverName', 'command', 'header'])
+// `args` is modeled as a string: it appears both as a single-line array
+// (`args: ['/c', ...]`) and as a block sequence. The inline form is stored in
+// `cur.args` and re-emitted as a REAL YAML flow array on render — writing it
+// back as a quoted string would violate dsh-mcp-client's schema (args:
+// string[]) and crash the next boot. The block form is kept verbatim
+// (argsLines) and re-emitted unchanged.
+// `url` is preserved verbatim: it may be a `!!js` expression
+// (`url: !!js (process.env.X || '') && ('https://...')`), and re-emitting it
+// through a quoted scalar would turn the `!!js` tag into literal text, breaking
+// the server on the next boot. Keeping it raw preserves the expression.
+const PRESERVE_KEYS = new Set(['args', 'url'])
+// Keys that `renderServer` emits itself (fixed `name`, the `config:` container
+// opener). They must be dropped on parse so the rewrite doesn't duplicate them.
+const SKIP_KEYS = new Set(['name', 'config'])
+
+/**
+ * Parse server entries (4-space-indented `- id: mcp-*`) inside the MCP block.
+ * Each server keeps a `preserve` string of the config lines we don't model
+ * (env blocks, `!!js` lines, any other keys) so a rewrite never drops them.
+ */
+function parseMcpServers(blockText) {
+  const lines = blockText.split('\n')
+  const servers = []
+  let cur = null
+  let curIndent = 0
+  // When we hit `args:` with no inline value, the following deeper-indented
+  // `- ` list items are a block sequence we must keep verbatim and re-emit
+  // under `args:`. `argsSeqIndent` is that sequence's indent (-1 = not collecting).
+  let argsSeqIndent = -1
+  for (const line of lines) {
+    const idm = line.match(/^(\s*)- id:\s*["']?(mcp-[^\s"']+)["']?\s*$/)
+    if (idm) {
+      if (cur) servers.push(cur)
+      cur = {
+        id: idm[2],
+        name: idm[2].replace(/^mcp-/, ''),
+        transport: '',
+        serverName: '',
+        url: '',
+        command: '',
+        args: '',
+        argsLines: [],
+        header: '',
+        preserve: '',
+      }
+      curIndent = idm[1].length
+      argsSeqIndent = -1
+      continue
+    }
+    if (!cur) continue
+    const indentMatch = line.match(/^(\s*)/)
+    const indent = indentMatch ? indentMatch[1].length : 0
+    if (line.trim().length === 0) continue
+    // A sibling server at the same indent ends this entry.
+    if (indent === curIndent && /^- id:/.test(line)) continue
+    if (indent <= curIndent) {
+      // Left the config entirely (or a sibling): stop collecting args.
+      argsSeqIndent = -1
+      if (cur) { servers.push(cur); cur = null }
+      continue
+    }
+    // While collecting an args block sequence, every deeper list item is kept.
+    // Store the BARE value (strip the leading "- " and any quotes) so the
+    // frontend can join it into a space-separated args string and renderServer
+    // can re-emit it with safeScalar — keeping "- " prefixes out of the value.
+    if (argsSeqIndent >= 0 && indent >= argsSeqIndent && /^\s*- /.test(line)) {
+      cur.argsLines.push(stripListScalar(line))
+      continue
+    }
+    const kv = line.match(/^\s+(\w+):\s*(.*)$/)
+    if (kv) {
+      const key = kv[1]
+      const val = stripQuotes(kv[2].trim())
+      if (SKIP_KEYS.has(key)) continue
+      if (key === 'args') {
+        // Inline array: `args: [...]` -> string. Block sequence: start collecting.
+        if (val.length) cur.args = val
+        else argsSeqIndent = indent + 2
+        continue
+      }
+      if (key === 'url') {
+        cur.url = val
+        // Plain http(s) urls are re-emitted from `cur.url` on render, so they
+        // must NOT also land in `preserve` (that would duplicate the line and,
+        // worse, make a `url` edit get clobbered by the stale preserve line).
+        // A `!!js`/process.env expression cannot be re-emitted through
+        // safeScalar (the tag would become literal text), so it falls through
+        // to `preserve` and is kept verbatim.
+        if (!looksLikeExpression(val)) continue
+      }
+      if (KNOWN_KEYS.has(key)) {
+        if (key === 'serverName') cur.serverName = val
+        else if (key === 'transport') cur.transport = val
+        else if (key === 'command') cur.command = val
+        else if (key === 'header') cur.header = val
+        continue
+      }
+    }
+    // Anything else (env:, !!js, nested keys) is preserved verbatim.
+    cur.preserve += (cur.preserve ? '\n' : '') + line
+  }
+  if (cur) servers.push(cur)
+  return servers
+}
+
+// Emit a YAML scalar safely for arbitrary user input. We always use double
+// quotes with JSON-style escaping: it is a single line, so it can never
+// disturb the surrounding block indentation (a block scalar like `|-` would
+// swallow the following lines). Double quotes in YAML accept the same
+// \n \t \" \\ escapes as JSON.
+function safeScalar(value) {
+  const v = value === undefined || value === null ? '' : String(value)
+  if (v === '') return "''"
+  const escaped = v
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\t/g, '\\t')
+    .replace(/\r/g, '\\r')
+  return '"' + escaped + '"'
+}
+
+// Turn a connector args field into a real argument list: a JS/JSON array
+// literal string ("['/c', 'npx', ...]") is parsed, anything else is split on
+// whitespace. Keeps dsh-mcp-client's schema (args: string[]) satisfied.
+function parseArgsValue(raw) {
+  const text = String(raw ?? '').trim()
+  if (!text) return ['']
+  if (/^\[.*\]$/s.test(text)) {
+    try {
+      const arr = JSON.parse(text.replace(/'/g, '"'))
+      if (Array.isArray(arr)) return arr.map((x) => String(x))
+    } catch {}
+  }
+  // Quote-aware tokenizer (learned from dsh-mcp-manager's parseArgs): arguments
+  // wrapped in "..." or '...' stay intact even when they contain spaces, so
+  // e.g. `--header "Authorization: Bearer x"` becomes two argv tokens instead
+  // of being split on every whitespace.
+  const out = []
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g
+  let m
+  while ((m = re.exec(text))) out.push(m[1] ?? m[2] ?? m[3])
+  return out
+}
+
+// dsh-mcp-client only accepts `headers` (an object) on streamable-http. A
+// bare `header: "k: v"` line on stdio violates the schema and crashes the next
+// boot, so we only render it for http, and only in the map form.
+function renderHeader(s) {
+  if (!s.header || (s.transport || 'stdio') !== 'streamable-http') return []
+  const hm = /^([^:]+):\s*(.*)$/.exec(s.header)
+  if (!hm) return []
+  const key = hm[1].trim().replace(/"/g, '\\"')
+  return [`        headers: { "${key}": ${safeScalar(hm[2].trim())} }`]
+}
+
+function renderServer(s) {
+  const out = []
+  out.push(`    - id: ${safeScalar(s.id)}`)
+  out.push(`      name: '@deepseek-ai/dsh-mcp-client'`)
+  out.push(`      config:`)
+  out.push(`        transport: ${safeScalar(s.transport || 'stdio')}`)
+  if (s.serverName) out.push(`        serverName: ${safeScalar(s.serverName)}`)
+  // Plain http(s) urls are emitted here; `!!js`/process.env expressions stay
+  // in `preserve` and come back verbatim (safeScalar would break the tag).
+  if (s.url && !looksLikeExpression(s.url)) out.push(`        url: ${safeScalar(s.url)}`)
+  if (s.command) out.push(`        command: ${safeScalar(s.command)}`)
+  out.push(...renderHeader(s))
+  // args: either a real flow array, or a verbatim block sequence.
+  if (s.argsLines && s.argsLines.length) {
+    out.push(`        args:`)
+    for (const item of s.argsLines) out.push(`          - ${safeScalar(item)}`)
+  } else if (s.args) {
+    out.push(`        args: [${parseArgsValue(s.args).map(safeScalar).join(', ')}]`)
+  }
+  if (s.preserve) {
+    const trimmed = s.preserve.trimEnd()
+    if (trimmed.length) out.push(trimmed)
+  }
+  return out.join('\n')
+}
+
+/**
+ * Rebuild the full patch text. `servers` is the desired server list (each may
+ * carry a `preserve` string from the original file; callers pass it through so
+ * env / !!js lines survive). When no MCP servers remain, the block is dropped.
+ */
+function buildPatch(text, servers) {
+  const found = findMcpBlock(text)
+  if (!found) {
+    if (!servers.length) return text
+    const block =
+      `\n# MCP servers managed by @omdp/dsh-connector\n` +
+      `- insert:\n` +
+      servers.map(renderServer).join('\n') +
+      '\n'
+    return text.replace(/\n*$/, '\n') + block
+  }
+  // When every MCP server is removed, drop the whole insert block instead of
+  // leaving a bare `- insert:` (that would render as `insert: null` and could
+  // break the loader on the next boot).
+  if (!servers.length) return found.head + found.tail
+  const body = servers.map(renderServer).join('\n') + '\n'
+  return found.head + `- insert:\n` + body + found.tail
+}
+
+/* ───────────────────────────── Skills ──────────────────────────────────── */
+
+function isAbsent(error) {
+  return typeof error === 'object' && error !== null && error.code === 'ENOENT'
+}
+
+function parseFrontmatter(raw) {
+  const firstLineEnd = raw.indexOf('\n')
+  if (firstLineEnd < 0) return undefined
+  const firstLine = raw.slice(0, firstLineEnd).replace(/\r$/, '')
+  if (firstLine !== '---') return undefined
+  const start = firstLineEnd + 1
+  let lineStart = start
+  while (lineStart <= raw.length) {
+    const nextNewline = raw.indexOf('\n', lineStart)
+    const lineEnd = nextNewline < 0 ? raw.length : nextNewline
+    const line = raw.slice(lineStart, lineEnd).replace(/\r$/, '')
+    if (line === '---') {
+      const yamlText = raw.slice(start, lineStart)
+      let data
+      try {
+        data = parseYaml(yamlText)
+      } catch {
+        return undefined
+      }
+      if (typeof data !== 'object' || data === null || Array.isArray(data)) return undefined
+      const body = raw.slice(lineEnd + 1).replace(/^\r?\n/, '')
+      return { data, body }
+    }
+    lineStart = nextNewline < 0 ? raw.length + 1 : nextNewline + 1
+  }
+  return undefined
+}
+
+function serializeSkill(skill) {
+  const fm = { name: skill.name }
+  if (skill.description !== undefined) fm.description = skill.description
+  if (skill.whenToUse !== undefined) fm.whenToUse = skill.whenToUse
+  if (skill.modelInvocable !== undefined) fm.modelInvocable = skill.modelInvocable
+  if (skill.userInvocable !== undefined) fm.userInvocable = skill.userInvocable
+  const head = '---\n' + stringifyYaml(fm) + '---\n'
+  return head + (skill.content || '')
+}
+
+async function readUserSkill(home, name) {
+  const path = join(skillsRoot(), name, 'SKILL.md')
+  let raw
+  try {
+    raw = await readFile(path, 'utf8')
+  } catch (error) {
+    if (isAbsent(error)) return undefined
+    throw error
+  }
+  const fm = parseFrontmatter(raw)
+  if (!fm) return { name, description: '', content: raw }
+  return {
+    name: fm.data.name ?? name,
+    description: fm.data.description ?? '',
+    whenToUse: fm.data.whenToUse,
+    modelInvocable: fm.data.modelInvocable,
+    userInvocable: fm.data.userInvocable,
+    content: fm.body,
+  }
+}
+
+async function listUserSkills() {
+  const root = skillsRoot()
+  let entries
+  try {
+    entries = await readdir(root, { withFileTypes: true })
+  } catch (error) {
+    if (isAbsent(error)) return []
+    throw error
+  }
+  const out = []
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const skill = await readUserSkill(resolveHome(), entry.name)
+    if (skill) out.push({ name: skill.name, description: skill.description || '' })
+  }
+  return out
+}
+
+async function saveUserSkill(home, skill) {
+  if (!SKILL_NAME.test(skill.name)) {
+    throw new Error(`invalid skill name "${skill.name}" (kebab-case only)`)
+  }
+  // A bare `---` line inside the body would be mistaken for the frontmatter
+  // terminator on read and truncate the skill. Reject it up front.
+  if (skill.content && /(^|\n)\s*---\s*(\n|$)/.test(skill.content)) {
+    throw new Error('skill content must not contain a standalone "---" line')
+  }
+  const dir = join(skillsRoot(), skill.name)
+  const file = join(dir, 'SKILL.md')
+  const serialized = serializeSkill(skill)
+  // Round-trip check: the file we are about to write must parse back into a
+  // valid skill (name + at least one closing delimiter). If not, refuse.
+  if (!parseFrontmatter(serialized)) {
+    throw new Error('generated SKILL.md is not valid (frontmatter missing or unterminated)')
+  }
+  await mkdir(dir, { recursive: true })
+  await writeFile(file, serialized, 'utf8')
+  return { path: file }
+}
+
+async function removeUserSkill(home, name) {
+  if (!SKILL_NAME.test(name)) throw new Error(`invalid skill name "${name}"`)
+  await rm(join(skillsRoot(), name), { recursive: true, force: true })
+}
+
+/* ─────────────────────── MCP server validation ─────────────────────────
+ * The authoritative gate between the UI and the patch file: every field the
+ * user can type is checked against the exact contract dsh-mcp-client enforces
+ * at boot (transport enum, serverName pattern) plus the OS-level constraints
+ * that make a stdio spawn actually work (command must resolve to something
+ * executable; no spaces/quotes that would break the cmd command line) and the
+ * streamable-http contract (url must parse as an http(s) URL). A value that
+ * fails here would either crash the next boot (schema reject) or spam cmd
+ * errors ('a' is not recognized...) — both are rejected before writing.
+ * ────────────────────────────────────────────────────────────────────────── */
+
+// A `!!js` url expression (e.g. `!!js (process.env.X || '') && ('https://...')`)
+// is evaluated by the harness at activation, so its raw text cannot be URL
+// checked. Anything that looks like an expression is exempted.
+function looksLikeExpression(value) {
+  const text = String(value ?? '').trim()
+  return text.startsWith('!!js') || text.includes('process.env') || text.includes('&&') || text.startsWith('(')
+}
+
+// Windows has no `which`; PATH lookup mirrors cmd's own resolution. A
+// path-like command (contains a separator or a known script/exec extension)
+// must exist on disk instead — `where` would not resolve a bare `.js`.
+function commandResolvable(command) {
+  if (/[\\/]/.test(command) || /\.(js|mjs|cjs|cmd|bat|exe|ps1|py)$/i.test(command)) {
+    return existsSync(command)
+  }
+  if (process.platform === 'win32') {
+    const r = spawnSync('where', [command], { stdio: 'ignore' })
+    return r.status === 0
+  }
+  const r = spawnSync('which', [command], { stdio: 'ignore' })
+  return r.status === 0
+}
+
+// One string field shared by every server entry; returns the first problem.
+function checkScalar(label, value) {
+  if (typeof value !== 'string') return `${label} must be a string`
+  if (CONTROL_CHARS.test(value)) return `${label} must not contain control characters`
+  return null
+}
+
+// Full validation for one server object (raw from the request body). Returns
+// an array of human-readable problems; empty means it is safe to write.
+function validateServer(s) {
+  const problems = []
+  const id = String(s.id ?? '')
+  if (!MCP_ID_RE.test(id)) {
+    problems.push(`invalid server id ${JSON.stringify(id)} (must be mcp-<kebab-case>, e.g. mcp-github)`)
+  }
+  const transport = String(s.transport ?? 'stdio')
+  if (!TRANSPORTS.has(transport)) {
+    problems.push(`server ${JSON.stringify(id)}: transport ${JSON.stringify(transport)} is not supported (use stdio or streamable-http)`)
+  }
+  const name = String(s.serverName ?? '')
+  if (!SERVER_NAME_RE.test(name)) {
+    problems.push(`server ${JSON.stringify(id)}: serverName ${JSON.stringify(name)} must match ${String(SERVER_NAME_RE)} (harness contract)`)
+  }
+  for (const [label, key] of [['command', 'command'], ['url', 'url'], ['header', 'header'], ['args', 'args']]) {
+    if (typeof s[key] === 'string') {
+      const problem = checkScalar(`${JSON.stringify(id)}.${label}`, s[key])
+      if (problem) problems.push(problem)
+    }
+  }
+  if (transport === 'stdio') {
+    const command = String(s.command ?? '')
+    if (!command.trim()) {
+      problems.push(`server ${JSON.stringify(id)}: command is required for stdio transport`)
+    } else if (/\s|['"]/.test(command)) {
+      problems.push(`server ${JSON.stringify(id)}: command must be a single token (no spaces or quotes), e.g. node or npx`)
+    } else if (!commandResolvable(command)) {
+      problems.push(`server ${JSON.stringify(id)}: command ${JSON.stringify(command)} not found — check the name or the full path`)
+    }
+  }
+  if (transport === 'streamable-http') {
+    const url = String(s.url ?? '')
+    if (!url.trim()) {
+      problems.push(`server ${JSON.stringify(id)}: url is required for streamable-http transport`)
+    } else if (!looksLikeExpression(url)) {
+      try {
+        const parsed = new URL(url)
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+          problems.push(`server ${JSON.stringify(id)}: url must be http(s)`)
+        }
+      } catch {
+        problems.push(`server ${JSON.stringify(id)}: url ${JSON.stringify(url)} is not a valid URL`)
+      }
+    }
+  }
+  return problems
+}
+
+/* ─────────────────────────── HTTP API ──────────────────────────────────── */
+
+function json(res, code, value) {
+  res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' })
+  res.end(JSON.stringify(value))
+}
+
+async function readBody(req) {
+  const chunks = []
+  for await (const chunk of req) chunks.push(chunk)
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}')
+  } catch {
+    return {}
+  }
+}
+
+export function apply(ctx) {
+  async function route(req, res) {
+    const url = new URL(req.url, 'http://localhost')
+    const path = url.pathname
+    try {
+      if (!path.startsWith(API_PREFIX)) { res.writeHead(404); res.end(); return }
+
+      // GET /api/mcp — list server entries (with preserve buckets)
+      if (req.method === 'GET' && path === API_PREFIX + '/mcp') {
+        let text
+        try {
+          text = await readFile(patchPath(), 'utf8')
+        } catch (error) {
+          if (isAbsent(error)) return json(res, 200, { servers: [], exists: false })
+          throw error
+        }
+        const found = findMcpBlock(text)
+        const servers = found ? parseMcpServers(found.blockText) : []
+        return json(res, 200, { servers, exists: true })
+      }
+
+      // POST /api/mcp — replace server entries. Preserve env/!!js from the
+      // existing entry with the same id so edits never drop credentials.
+      if (req.method === 'POST' && path === API_PREFIX + '/mcp') {
+        const body = await readBody(req)
+        if (!Array.isArray(body.servers)) {
+          return json(res, 400, { error: 'malformed request body: servers must be an array' })
+        }
+        // Authoritative validation gate: any problem (bad transport, invalid
+        // serverName, unresolvable command, invalid url, control characters)
+        // rejects the whole save with a specific message BEFORE it reaches the
+        // patch — a bad entry would crash the next boot, so it must never be
+        // written.
+        for (const s of body.servers) {
+          const problems = validateServer(s)
+          if (problems.length) {
+            return json(res, 400, { error: problems.join('; ') })
+          }
+        }
+        let text
+        try {
+          text = await readFile(patchPath(), 'utf8')
+        } catch (error) {
+          if (isAbsent(error)) text = '# Managed by @omdp/dsh-connector\n[]\n'
+          else throw error
+        }
+        const existing = new Map()
+        const found = findMcpBlock(text)
+        if (found) for (const s of parseMcpServers(found.blockText)) existing.set(s.id, s)
+        const servers = body.servers.map((s) => {
+          const prev = existing.get(s.id)
+          return prev ? { ...s, preserve: s.preserve || prev.preserve } : s
+        })
+        const next = buildPatch(text, servers)
+        // Validate the entire resulting patch parses as YAML before writing.
+        // cordis.patch.yml uses `!!js` tags; the parser tolerates them via
+        // silent log level (values stay raw, nothing printed), so a successful
+        // parse here means DSH can load it too. If it does NOT parse, refuse
+        // to write — better to reject the edit than crash dsh on next boot.
+        try {
+          parseYaml(next, { logLevel: 'silent' })
+        } catch (err) {
+          return json(res, 422, { ok: false, error: 'generated patch is not valid YAML: ' + (err && err.message ? err.message : String(err)) })
+        }
+        await mkdir(dirname(patchPath()), { recursive: true })
+        // Atomic replace: write to a temp file, then rename over the original
+        // so a crash mid-write cannot leave a half-written patch behind.
+        const target = patchPath()
+        const tmp = target + '.tmp'
+        await writeFile(tmp, next, 'utf8')
+        await rename(tmp, target)
+        return json(res, 200, { ok: true })
+      }
+
+      // GET /api/skills — list
+      if (req.method === 'GET' && path === API_PREFIX + '/skills') {
+        const skills = await listUserSkills()
+        return json(res, 200, { skills })
+      }
+
+      // PUT /api/skills — save
+      if (req.method === 'PUT' && path === API_PREFIX + '/skills') {
+        const body = await readBody(req)
+        // Guard against malformed bodies (readBody falls back to {} on bad
+        // JSON): without this, `name` could be undefined and, matching the
+        // kebab-case regex as the string "undefined", create a junk skill.
+        if (typeof body !== 'object' || body === null || Array.isArray(body) || typeof body.name !== 'string') {
+          return json(res, 400, { error: 'malformed request body: skill name (string) is required' })
+        }
+        const written = await saveUserSkill(resolveHome(), body)
+        return json(res, 200, { ok: true, path: written.path })
+      }
+
+      const skMatch = path.match(new RegExp('^' + API_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '/skills/([^/]+)$'))
+
+      // GET /api/skills/:name — get one
+      if (req.method === 'GET' && skMatch) {
+        const name = decodeURIComponent(skMatch[1])
+        // Validate before touching the filesystem: a crafted `..%2F..%2F`
+        // name could otherwise escape ~/.dsh/skills and read arbitrary files.
+        if (!SKILL_NAME.test(name)) return json(res, 400, { error: 'invalid skill name' })
+        const skill = await readUserSkill(resolveHome(), name)
+        if (!skill) return json(res, 404, { error: 'skill not found' })
+        return json(res, 200, skill)
+      }
+
+      // DELETE /api/skills/:name — remove
+      if (req.method === 'DELETE' && skMatch) {
+        const name = decodeURIComponent(skMatch[1])
+        if (!SKILL_NAME.test(name)) return json(res, 400, { error: 'invalid skill name' })
+        await removeUserSkill(resolveHome(), name)
+        return json(res, 200, { ok: true })
+      }
+
+      res.writeHead(404)
+      res.end()
+    } catch (error) {
+      const logger = ctx.get('logger')
+      if (logger && typeof logger.error === 'function') logger.error(`connector api: ${error?.stack ?? error}`)
+      json(res, 500, { error: String(error?.message ?? error).slice(0, 300) })
+    }
+  }
+
+  const handle = ctx.webServer.register({ kind: 'prefix', path: '/connector', handler: route })
+  ctx.effect(() => handle)
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@omdp/dsh-connector",
+  "version": "0.1.0",
+  "description": "Unified DeepSeek Harness connector: edit MCP servers (cordis.patch.yml) and user skills (~/.dsh/skills) from one Web UI settings page.",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "dsh": {
+    "client": {
+      "platform": "web",
+      "inject": [
+        "slots"
+      ]
+    },
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "mcp",
+    "skill",
+    "cordis"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/XJungit/omdp.git",
+    "directory": "dsh-connector"
+  },
+  "dependencies": {
+    "yaml": "^2.9.0"
+  }
+}