dsh-mcp-connector 0.2.17 → 0.2.19

package/CHANGELOG.md

@@ -4,6 +4,34 @@
 
 ## [Unreleased]
 
+## [0.2.19] - 2026-08-24
+
+### Fixed
+
+- 所有对话工具结果在交给 DSH Host 前统一转换为 lossless JSON，清理 `undefined`、非有限数字、`BigInt`、稀疏数组和循环引用，修复 Windows DSH Desktop 的 `value is not lossless JSON` 错误。
+- UI 静态文件路由不再使用平台相关的 `path.normalize` 处理 URL，Windows 下保持正斜杠语义并继续拒绝路径穿越，修复市场 iframe 返回 404。
+
+### Documentation
+
+- 中英文 README 更新为公共 Registry 61 条、与 4 张随包卡片合并后 65 张市场卡片的当前规模；重新采集市场总览并重建 16 秒演示 GIF。
+
+### Verification
+
+- 插件 94 项自动测试、lint、npm 发布文件白名单/敏感内容扫描和 `git diff --check` 通过。
+- 手动执行最新 Registry `main` 的 61 项健康巡检：60 项通过、1 项部分通过；44 个远程 MCP Server 全部可达并识别成功，28 个 stdio Server 按安全策略未执行本地命令。
+
+## [0.2.18] - 2026-08-24
+
+### Added
+
+- 市场 stdio 连接器支持声明多个凭据输入字段，并将用户在本机填写的值安全绑定到指定环境变量；目录仍禁止携带真实凭据，Registry 探针仍不执行本地命令。
+- OAuth 动态客户端注册支持 `client_secret_post` 与 `client_secret_basic`，客户端密钥随本机 Grant 用于授权码交换、刷新和撤销。
+
+### Security
+
+- stdio 凭据值不进入 catalog/status/log；字段映射会校验环境变量名、未知引用、重复声明和未使用的必填字段。
+- OAuth DCR 客户端密钥不进入公开输出，并支持服务端提供的到期时间检查。
+
 ## [0.2.17] - 2026-08-24
 
 ### Documentation
@@ -303,7 +331,15 @@
 - 外部 URL 与导入 Header 执行安全校验。
 - iframe 消息校验同源和消息来源。
 
-[Unreleased]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.11...HEAD
+[Unreleased]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.19...HEAD
+[0.2.19]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.18...v0.2.19
+[0.2.18]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.17...v0.2.18
+[0.2.17]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.16...v0.2.17
+[0.2.16]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.15...v0.2.16
+[0.2.15]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.14...v0.2.15
+[0.2.14]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.13...v0.2.14
+[0.2.13]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.12...v0.2.13
+[0.2.12]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.11...v0.2.12
 [0.2.11]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.10...v0.2.11
 [0.2.10]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.9...v0.2.10
 [0.2.9]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.8...v0.2.9

package/README.en.md

@@ -18,21 +18,21 @@ Browse and install MCP connectors from different providers in DeepSeek Harness D
 
 - A primary sidebar entry below New Conversation and above workspaces/conversations, with a public footer-slot fallback for incompatible DSH DOM versions.
 - Searchable Marketplace and Installed views; the default Marketplace groups cards into Featured plus nine business-category sections, previews four cards per section, keeps the category bar visible while scrolling, and shows every card when a single category is selected.
-- OAuth 2.0 Authorization Code with PKCE, API key/Bearer/unauthenticated HTTP configuration, stdio local-process configuration, and `mcpServers` JSON import.
+- OAuth 2.0 Authorization Code with PKCE, including DCR public clients and `client_secret_post` / `client_secret_basic`; API key/Bearer/unauthenticated HTTP configuration, stdio local-process configuration, and `mcpServers` JSON import.
 - Installation from a credential-free connector descriptor URL.
-- Credential and MCP initialize validation before API-key connectors are saved as installed.
+- Credential and MCP initialize validation before HTTP API-key connectors are saved as installed, plus declarative multi-field credential-to-env bindings for marketplace stdio connectors.
 - Dynamic tool discovery grouped by MCP server, including descriptions, search, batched rendering, and an independent scroll region.
 - Curated prompt templates that can open a DSH conversation and prefill its draft; missing variables are requested before the prompt is sent.
-- Persistent connection lifecycle management: restore on restart, enable/disable, disconnect, refresh OAuth tokens, and revoke authorization.
+- Persistent connection lifecycle management: restore on restart, enable/disable, disconnect, refresh OAuth tokens, and revoke authorization. DCR client secrets are kept with the local grant only.
 - Built-in, remote, and local catalogs with `published` and `featured` controls.
 - A standalone remote Registry, allowing new marketplace cards to appear after refresh without publishing a new npm version.
 - Explicit, non-destructive migration of authorization from the two earlier Qichacha OAuth plugins.
 
-The first four bundled cards are Qichacha connectors, followed by PKULaw and Wind. After a remote Registry refresh, Yingmi, QVeris, Bazhuayu Cloud Collection, GitHub, Cloudflare, Notion, Tavily, and the Ace Data Cloud-hosted Seedream connector are also available, for 14 published marketplace cards after deduplication. Recommendations are limited to the four Qichacha cards, PKULaw, and Wind; all other connectors remain discoverable in their business categories.
+As of August 24, 2026, the public Registry publishes 61 connector descriptors. After merging and deduplicating them with the four bundled Qichacha cards, the Marketplace exposes 65 cards across nine business categories. Recommendations remain limited to the four Qichacha cards, PKULaw, and Wind, for six featured cards in total. The Registry can evolve independently, so the badge shown after a client refresh is the authoritative current count.
 
 ## Interface and demo
 
-![30-second MCP Connector walkthrough](https://raw.githubusercontent.com/duhu2000/dsh-mcp-connector/main/docs/demo.gif)
+![16-second MCP Connector walkthrough](https://raw.githubusercontent.com/duhu2000/dsh-mcp-connector/main/docs/demo.gif)
 
 | Marketplace overview | Connector details and curated prompts |
 |---|---|
@@ -105,7 +105,7 @@ npm run dev:ui
 
 `npm run check` performs syntax checks, automated tests, and an npm package allowlist/sensitive-content audit. `npm run market:check` tracks the external DSH marketplace PR and live directory. Tags matching `v*` trigger GitHub Actions; the tag must match `package.json`. npm releases use Trusted Publishing through GitHub OIDC and do not require a long-lived `NPM_TOKEN`.
 
-The current public version is [`dsh-mcp-connector@0.2.17`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.17](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.17).
+The current public version is [`dsh-mcp-connector@0.2.19`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.19](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.19).
 
 See [CHANGELOG.md](CHANGELOG.md) for version history and [docs/DESKTOP-E2E.md](docs/DESKTOP-E2E.md) for the Desktop release checklist.
 
@@ -116,7 +116,8 @@ See [CHANGELOG.md](CHANGELOG.md) for version history and [docs/DESKTOP-E2E.md](d
 - External URLs must use HTTPS; HTTP is allowed only for loopback development.
 - Remote descriptors and catalogs are limited to 2 MiB, Web API requests to 1 MiB, and imported JSON is scanned for credential fields before normalization.
 - Streamable HTTP and stdio are supported end to end. Legacy `sse` entries are normalized to Streamable HTTP. The connector passes stdio `command/args/env/cwd` to `@deepseek-ai/dsh-mcp-client` instead of reimplementing process transport.
-- stdio starts a local process. Import or connect only trusted commands and packages; catalog descriptors may not contain token/secret-shaped environment variables.
+- stdio starts a local process. Import or connect only trusted commands and packages. Catalog descriptors may declare `credentialFields` and `credentialBindings`, but may never contain actual token/secret values; user input is injected only into the local Host process environment.
+- OAuth DCR client secrets share the same local-only boundary as access and refresh tokens and are omitted from catalog/status responses and logs.
 - The primary sidebar placement uses the stable DSH `data-slot` marker and falls back to the footer if that marker is removed.
 
 ## License

package/README.md

@@ -21,20 +21,20 @@
 - 图形化添加：手动 HTTP/stdio、`mcpServers` JSON、连接器描述 URL 三种入口，失败时保留表单并给出修复建议。
 - 连接器详情：精选 Prompt 优先展示，点击可带入 DSH 新会话；工具按 Server 分组，支持描述、搜索和独立滚动。
 - Prompt 模板：使用 `{{company}}` 等变量，发送前填写真实查询主体。
-- 三种接入：OAuth 2.0 PKCE、自定义 HTTP/stdio、导入 `mcpServers` JSON；也支持从连接器描述 URL 安装。
-- 市场 Bearer/API Key 连接器先执行 MCP initialize 连通性与凭据校验，全部 Server 通过后才持久化凭据并进入“已安装”。
-- 生命周期管理：连接持久化、重启恢复、启停、断开、OAuth 刷新与撤销。
+- 三种接入：OAuth 2.0 PKCE、自定义 HTTP/stdio、导入 `mcpServers` JSON；也支持从连接器描述 URL 安装。OAuth 动态注册兼容公共客户端以及 `client_secret_post` / `client_secret_basic` 机密客户端。
+- 市场 Bearer/API Key 连接器先执行 MCP initialize 连通性与凭据校验，全部 HTTP Server 通过后才持久化凭据并进入“已安装”；stdio 卡片可声明多个本机凭据字段及其环境变量映射。
+- 生命周期管理：连接持久化、重启恢复、启停、断开、OAuth 刷新与撤销；DCR 返回的客户端密钥与 Token 一同只保存在本机。
 - 目录运营：内置目录、远程 registry、本地覆盖，支持 `published` 上下架与 `featured` 精选。
 - 独立远程 Registry：新市场卡片合并后客户端刷新即可见，无需重新发布 npm；远程不可用时自动回退内置目录。
 - Registry 工具链：Schema/唯一性/密钥审计、MCP/OAuth 无凭据探针、每周健康巡检。
 - 平滑迁移：显式扫描并复制两个旧企查查 OAuth 插件授权；不删除原插件或原凭据。
 - 对话工具：`mcp_connector_catalog`、`connect`、`configure`、`import_json`、`install_from_url`、`status`、`health_check`、`set_enabled`、`disconnect`、`refresh_catalog`、`publish`、`tools_list`。
 
-随包目录前 4 张为企查查连接器，另含“北大法宝·法律检索”和“Wind·股票数据”。远程 Registry 刷新后还会加入“盈米·基金投顾”、“QVerisMCP”、“八爪鱼·云采集”、GitHub、Cloudflare、Notion、Tavily 和由 Ace Data Cloud 托管的 Seedream，合并去重后当前共 14 张已发布市场卡片。推荐位严格保留 4 张企查查卡片、北大法宝和 Wind；其他连接器按业务分类展示。
+截至 2026-08-24，公共 Registry 已发布 61 条连接器描述；与随包的 4 张企查查卡片合并去重后，市场页可浏览 65 张卡片，覆盖企业数据、金融投资、法律合规、开发工具、办公协作、调研分析、设计创意、效率工具和其他 9 类。推荐位严格保留 4 张企查查卡片、北大法宝和 Wind，共 6 张；其他连接器按业务分类展示。Registry 可独立持续更新，实际数量以客户端刷新后的市场页签徽标为准。
 
 ## 界面与演示
 
-![MCP 连接器 30 秒演示](https://raw.githubusercontent.com/duhu2000/dsh-mcp-connector/main/docs/demo.gif)
+![MCP 连接器 16 秒演示](https://raw.githubusercontent.com/duhu2000/dsh-mcp-connector/main/docs/demo.gif)
 
 | 市场总览 | 连接器详情与精选 Prompt |
 |---|---|
@@ -100,7 +100,7 @@ npm run dev:ui
 
 `check` 执行语法检查、自动测试和 npm 发布包白名单校验；`market:check` 检查外部 DSH 市场 PR 与线上目录；`dev:ui` 启动不含真实凭据的本地 mock 市场。CI 使用 `--legacy-peer-deps` 安装显式测试依赖，DSH 运行期 peer 仍由 Host 提供。`v*` Tag 会触发 GitHub Actions；Tag 必须与 `package.json` 版本一致。Release 通过 npm Trusted Publishing (GitHub OIDC) 发布，不依赖长期 `NPM_TOKEN`。
 
-当前公开版本为 [`dsh-mcp-connector@0.2.17`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.17](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.17)。
+当前公开版本为 [`dsh-mcp-connector@0.2.19`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.19](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.19)。
 
 版本能力与变更记录见 [CHANGELOG.md](CHANGELOG.md)。
 Desktop 发版回归见 [docs/DESKTOP-E2E.md](docs/DESKTOP-E2E.md)。
@@ -115,7 +115,8 @@ stdio 传输的架构、透传边界与安全约束见 [docs/STDIO-SUPPORT.md](d
 - 外部 URL 仅允许 HTTPS，HTTP 仅允许回环地址；导入配置会校验 URL 与 Header。
 - 远程目录/描述响应限制 2 MiB，Web API 请求限制 1 MiB；原始 JSON 在归一化前扫描凭据字段。
 - 完整覆盖 Streamable HTTP 与 stdio；旧 `sse` 配置在导入/恢复时归一为 Streamable HTTP。stdio 的 `command/args/env/cwd` 原样交给 `@deepseek-ai/dsh-mcp-client`，插件本身不重复实现进程传输。
-- stdio 会启动本机进程：仅导入或连接可信命令/软件包。市场目录不得携带 token/secret 类环境变量；用户凭据只允许在本机配置。
+- stdio 会启动本机进程：仅导入或连接可信命令/软件包。市场目录只能用 `credentialFields` + `credentialBindings` 声明输入与 env 映射，不得携带真实 token/secret；用户填写值只写入本机连接记录并交给 Host。
+- OAuth DCR 的 `client_secret` 与 Access/Refresh Token 采用相同的本机存储边界，不会进入市场 API、状态输出或日志。
 - 顶部入口通过 DSH 稳定 `data-slot` 定位并使用 React Portal；DSH 若移除该标记，入口会回退到底部，不影响连接器功能。
 - 旧授权迁移必须显式确认，只复制不删除；确认新连接可用后再手动停用旧插件。
 

package/docs/MARKET-REGISTRATION.md

@@ -16,7 +16,7 @@
 3. 在插件中选择「添加连接 → 市场卡片」，粘贴 URL。
 4. Schema/密钥审计通过后，卡片会持久化到本机市场。
 
-Bearer/API Key 型连接器可在卡片上点「配置」，一次填写凭据后批量连接该卡片的所有 Server。
+Bearer/API Key 型连接器可在卡片上点「配置」，一次填写凭据后批量连接该卡片的所有 Server。stdio 卡片可通过 `auth.credentialFields` 声明多个输入，并用 `servers[].credentialBindings` 映射到本地进程环境变量；描述文件仍不得包含真实值。
 
 ## 3. 提交公共市场
 
@@ -47,8 +47,11 @@ Bearer/API Key 型连接器可在卡片上点「配置」，一次填写凭据
 - Authorization Server Metadata（RFC 8414）；
 - `authorization_endpoint`、`token_endpoint`、`registration_endpoint`；`revocation_endpoint` 建议提供，但按标准属于可选能力；
 - Dynamic Client Registration，且支持 loopback callback URI；
+- DCR 的 `token_endpoint_auth_method` 可为 `none`、`client_secret_post` 或 `client_secret_basic`；后两者的注册响应必须返回 `client_secret`；
 - Refresh Token；如提供撤销端点，插件会在断开/清理授权时撤销 Refresh Token，否则只删除 DSH 本机授权记录。
 
+DCR 返回的 `client_secret` 由插件与 Access/Refresh Token 一同保存在 DSH 本机 Grant 中，只用于 Token 交换、刷新和撤销，不会出现在目录、状态输出或日志。描述文件只填写服务端支持的 `tokenEndpointAuthMethod`，不得预置客户端密钥。
+
 插件优先读取 RFC 8414 Authorization Server Metadata；若动态注册或撤销端点缺失，会再读取 OIDC Discovery 并仅补齐缺失字段。OAuth 元数据中的授权、Token 等标准端点始终优先。
 
 符合上述条件的最小描述：
@@ -59,7 +62,7 @@ Bearer/API Key 型连接器可在卡片上点「配置」，一次填写凭据
   "id": "vendor-legal",
   "name": "厂商·法律数据",
   "vendor": "厂商名称",
-  "category": "法律数据",
+  "category": "法律合规",
   "summary": "法规与案例检索",
   "published": true,
   "auth": {
@@ -80,6 +83,36 @@ Bearer/API Key 型连接器可在卡片上点「配置」，一次填写凭据
 }
 ```
 
+### 5.1 需要本机环境变量的 stdio 卡片
+
+目录只声明字段和映射，示例见 `registry/connectors/stdio-credential.sample.json`：
+
+```json
+{
+  "auth": {
+    "mode": "api-key",
+    "credentialFields": [
+      { "key": "apiToken", "label": "API Token", "required": true, "secret": true },
+      { "key": "region", "label": "区域", "required": true, "secret": false }
+    ]
+  },
+  "servers": [{
+    "serverKey": "main",
+    "serverName": "vendor-local-service",
+    "transport": "stdio",
+    "command": "npx",
+    "args": ["-y", "@vendor/example-mcp-server"],
+    "env": { "LOG_LEVEL": "info" },
+    "credentialBindings": {
+      "VENDOR_API_TOKEN": "apiToken",
+      "VENDOR_REGION": "region"
+    }
+  }]
+}
+```
+
+`credentialBindings` 的 key 必须是合法环境变量名，value 必须引用已声明的字段。不要在 `env`、`credentialFields` 或其他目录字段中填写 Token、Secret、API Key、密码或 Cookie。
+
 ## 6. 北大法宝当前适配结论
 
 北大法宝当前公开文档的主路径是在控制台生成 Access Token，然后通过 `Authorization: Bearer ...` 访问多个 MCP Server。因此：

package/docs/STDIO-SUPPORT.md

@@ -146,12 +146,13 @@ const Config = z.union([
 
 采用「宽松 schema + normalize 阶段显式校验」风格（与现有代码注释「宽松校验、显式报错」一致）。
 
-### 决策 3：stdio 鉴权通过 `env`，不抽象 `auth.mode`
+### 决策 3：stdio 凭据使用声明式字段绑定，真实值仅在本机注入 `env`
 
-- stdio 是本地进程，密钥通过环境变量传递（如 `GITHUB_TOKEN`、`OPENAI_API_KEY`）
-- 每个 server 的密钥 env 变量名不同，无法统一抽象成 `auth.mode` 的 header 机制
-- 设计：目录里 stdio 连接器的 `env` 只含非敏感默认值；用户 configure 时填含密钥的 env
-- stdio 型连接器的 `auth.mode` 保持 `none`（或 undefined）
+- stdio 是本地进程，密钥最终仍通过环境变量传递（如 `GITHUB_TOKEN`、`OPENAI_API_KEY`）。
+- 无凭据的 stdio 连接器使用 `auth.mode: "none"`；需要用户输入的卡片使用 `bearer` 或 `api-key`，并在 `auth.credentialFields` 声明一个或多个输入字段。
+- `servers[].credentialBindings` 只保存“环境变量名 → 凭据字段 key”的映射；`servers[].env` 只能包含非敏感默认值。
+- 用户输入存入本机 `ConnectionRecord.env` 并透传给 `dsh-mcp-client`，不回写目录，也不出现在 catalog/status/log 输出。
+- Registry 探针只校验声明与命令形状，绝不执行本地 stdio 命令。
 
 ### 决策 4：mcp-provision 按 transport 分支透传
 
@@ -611,9 +612,8 @@ cwd: { type: 'string', description: 'transport=stdio 时的工作目录，默认
 | stdio `command` 可执行任意本地命令 | command 来自（a）维护者审核的 catalog，或（b）用户主动 configure，风险可控；DSH 运行时沙箱机制兜底 |
 | `env` 里的密钥泄露到日志 | dsh-mcp-client 的 `buildChildEnv` 已用 `scrubbedParentEnv()` 清理敏感父环境变量；我们持久化 env 到 storage domain 与现有 headers 鉴权一致，无新增泄露面 |
 | `cwd` 空字符串导致 spawn 异常 | provisioning 层显式 `record.cwd \|\| process.cwd()` |
-| 目录夹带密钥 | 复用现有 `auditRawDescriptor` 的密钥字段审计，对 `env` 里的 `token/secret/key/password` 字段同样拦截（需在 §5.9 补测试） |
-
-> ⚠️ **需补充**：`catalog.js` 的 `auditDescriptor` / `auditRawDescriptor` 目前审计 `servers[].headers` 的密钥类字段，需确认 `servers[].env` 也被审计（避免目录里 stdio 的 env 夹带 token）。
+| 目录夹带密钥 | `auditRawDescriptor` 拒绝真实凭据字段，`auditDescriptor` 拒绝 `env` 中的 token/secret/API Key/password 类变量；只允许 `credentialBindings` 引用已声明字段 |
+| 凭据映射错误或未使用 | Schema 与目录审计检查字段 key、env 名、重复映射、未知引用及未被任何 HTTP/stdio Server 使用的必填字段 |
 
 ---
 
@@ -649,6 +649,8 @@ cwd: { type: 'string', description: 'transport=stdio 时的工作目录，默认
    - `npm run check`（lint + test + verify-pack）全绿
 4. **安全**：
    - 目录里 stdio 连接器的 `env` 含 token/secret 字段时被 `auditRawDescriptor` 拦截
+   - 多字段 `credentialFields` / `credentialBindings` 通过校验，未知引用与缺失必填值被拒绝
+   - 真实值只进入本机连接记录与 Host env，catalog/status/log 均不返回
 
 ---
 

package/docs/USER-GUIDE.md

@@ -69,7 +69,9 @@ dsh web
 
 Bearer/API Key 连接器会先执行 MCP `initialize` 验证。所有 Server 通过后，凭据才会保存并出现在“已安装”中；验证失败不会写入新凭据。
 
-OAuth 一键连接要求服务商支持标准 OAuth 2.1/PKCE 和公开元数据发现。插件不会要求用户把 OAuth Token 复制到聊天中。
+stdio 市场卡片也可能显示一个或多个凭据字段，例如 API Token、区域或租户标识。卡片目录只声明字段名称及其环境变量映射；提交后，真实值仅保存到 DSH 本机连接记录，并由插件注入该 stdio 进程的 `env`。市场、状态页和日志不会返回这些值。stdio 由 Host 托管，配置成功表示命令已注册；最终工具可用性仍以本机进程启动结果为准。
+
+OAuth 一键连接要求服务商支持标准 OAuth 2.1/PKCE 和公开元数据发现。动态客户端注册既支持无需客户端密钥的 `none`，也支持服务商签发密钥的 `client_secret_post` 与 `client_secret_basic`。客户端密钥仅与 OAuth Grant 一同保存在 DSH 本机，用于换取、刷新和撤销 Token；插件不会要求用户把 OAuth Token 或客户端密钥复制到聊天中。
 
 ## 5. 查看详情、Prompt 与工具
 
@@ -140,6 +142,8 @@ OAuth 断开时，插件会尽力调用服务商的撤销端点；无撤销端
 ## 8. 安全边界
 
 - 凭据仅保存在 DSH storage domain，不进入市场目录、Git 仓库或对话历史。
+- stdio 目录只能声明凭据字段与 env 映射，不能给出真实值；Registry 探针不会执行目录中的本地命令。
+- OAuth 动态注册返回的 `client_secret` 不出现在目录、连接状态或日志中；断开连接时与 Refresh Token 一起尽力撤销并删除本机记录。
 - 外部 HTTP 地址必须使用 HTTPS；仅本机回环开发地址允许 HTTP。
 - Registry 健康探针不持有用户凭据，也绝不会执行目录里的 stdio 命令。
 - 连接器能看到的数据和能执行的操作取决于你授予的账户权限；优先使用最小权限 Token/API Key。

package/lib/catalog.js

@@ -16,6 +16,11 @@ export function auditRawDescriptor(raw, path = 'connector') {
   if (!raw || typeof raw !== 'object') return raw;
   for (const [key, value] of Object.entries(raw)) {
     const fieldPath = `${path}.${key}`;
+    // credentialBindings 的 key 是待注入的环境变量名，value 只能是凭据字段引用；
+    // 真实值会在本机表单提交后写入 ConnectionRecord，不允许出现在目录中。
+    if (key === 'credentialBindings') continue;
+    // credentialFields[].secret 只是“以密码框显示”的布尔声明，不是密钥值。
+    if (key === 'secret' && typeof value === 'boolean' && /\.auth\.credentialFields\.\d+\.secret$/.test(fieldPath)) continue;
     if (SECRET_KEY_RE.test(key) && value !== undefined && value !== null && String(value).trim() !== '') {
       throw new Error(`${fieldPath} 禁止携带凭证或密钥`);
     }
@@ -38,16 +43,42 @@ export function loadBundledCatalog() {
 
 /** 安全审计：目录禁止携带密钥、URL 协议白名单、header 名白名单。 */
 export function auditDescriptor(descriptor) {
+  const credentialFields = descriptor.auth.credentialFields ?? [];
+  const credentialKeys = new Set();
+  for (const field of credentialFields) {
+    if (credentialKeys.has(field.key)) throw new Error(`connector "${descriptor.id}" auth.credentialFields key 重复: ${field.key}`);
+    credentialKeys.add(field.key);
+  }
+  const referencedCredentials = new Set();
   for (const server of descriptor.servers) {
     if (server.transport === 'stdio') {
-      if (descriptor.auth.mode !== 'none') {
-        throw new Error(`connector "${descriptor.id}" 的 stdio server 只能使用 auth.mode=none；凭据应由用户本机 env 配置`);
-      }
       for (const name of Object.keys(server.env ?? {})) {
         if (SECRET_ENV_RE.test(name)) {
           throw new Error(`connector "${descriptor.id}" servers[].env 禁止携带密钥类变量: ${name}`);
         }
       }
+      const bindings = server.credentialBindings ?? {};
+      if (descriptor.auth.mode === 'oauth2-pkce') {
+        throw new Error(`connector "${descriptor.id}" 的 stdio server 不支持 auth.mode=oauth2-pkce`);
+      }
+      if (descriptor.auth.mode === 'none' && Object.keys(bindings).length > 0) {
+        throw new Error(`connector "${descriptor.id}" 的 stdio credentialBindings 需要 bearer/api-key 凭据定义`);
+      }
+      if (['bearer', 'api-key'].includes(descriptor.auth.mode) && Object.keys(bindings).length === 0) {
+        throw new Error(`connector "${descriptor.id}" 的凭据型 stdio server 必须声明 credentialBindings`);
+      }
+      for (const [envName, credentialKey] of Object.entries(bindings)) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(envName)) {
+          throw new Error(`connector "${descriptor.id}" credentialBindings 环境变量名非法: ${envName}`);
+        }
+        if (Object.hasOwn(server.env ?? {}, envName)) {
+          throw new Error(`connector "${descriptor.id}" credentialBindings 与 servers[].env 重复声明: ${envName}`);
+        }
+        if (!credentialKeys.has(credentialKey)) {
+          throw new Error(`connector "${descriptor.id}" credentialBindings 引用了未知凭据字段: ${credentialKey}`);
+        }
+        referencedCredentials.add(credentialKey);
+      }
       continue;
     }
     assertSafeUrl(server.url);
@@ -58,6 +89,15 @@ export function auditDescriptor(descriptor) {
       }
     }
   }
+  if (['bearer', 'api-key'].includes(descriptor.auth.mode)) {
+    const httpServers = descriptor.servers.filter((server) => server.transport === 'streamable-http');
+    if (httpServers.length > 0 && credentialFields[0]) referencedCredentials.add(credentialFields[0].key);
+    for (const field of credentialFields) {
+      if (field.required && !referencedCredentials.has(field.key)) {
+        throw new Error(`connector "${descriptor.id}" 必填凭据字段未被 HTTP 或 stdio 使用: ${field.key}`);
+      }
+    }
+  }
   return descriptor;
 }
 

package/lib/connectors/oauth-connector.js

@@ -31,11 +31,17 @@ export async function oauthAuthorize({ connector, config, logger, signal }) {
   if (!issuer) throw new Error(`connector "${connector.id}" missing issuer`);
 
   const metadata = await discoverServerMetadata(issuer, config.requestTimeoutMs);
+  const requestedAuthMethod = connector.auth.tokenEndpointAuthMethod ?? 'none';
+  if (metadata.tokenEndpointAuthMethodsSupported.length > 0
+      && !metadata.tokenEndpointAuthMethodsSupported.includes(requestedAuthMethod)) {
+    throw new Error(`OAuth 服务不支持 token_endpoint_auth_method=${requestedAuthMethod}`);
+  }
   const callback = await startCallbackServer({ path: '/callback', timeoutMs: config.callbackTimeoutMs, signal });
   const registration = await registerClient(metadata.registrationEndpoint, {
     clientName: connector.auth.clientName,
     redirectUris: [callback.url],
     scope: connector.auth.scope,
+    tokenEndpointAuthMethod: requestedAuthMethod,
     timeoutMs: config.requestTimeoutMs,
   });
 
@@ -61,6 +67,8 @@ export async function oauthAuthorize({ connector, config, logger, signal }) {
 
   const token = await exchangeCode(metadata.tokenEndpoint, {
     clientId: registration.clientId,
+    clientSecret: registration.clientSecret,
+    tokenEndpointAuthMethod: registration.tokenEndpointAuthMethod,
     code,
     redirectUri: callback.url,
     codeVerifier: verifier,
@@ -83,6 +91,9 @@ export async function oauthAuthorize({ connector, config, logger, signal }) {
   return {
     issuer,
     clientId: registration.clientId,
+    clientSecret: registration.clientSecret,
+    clientSecretExpiresAt: registration.clientSecretExpiresAt,
+    tokenEndpointAuthMethod: registration.tokenEndpointAuthMethod,
     clientName: connector.auth.clientName,
     scope: connector.auth.scope,
     token,

package/lib/index.js

@@ -147,11 +147,17 @@ export async function apply(ctx, config) {
   async function refreshGrant(grantKey) {
     const entry = state.grants.get(grantKey);
     if (!entry || !entry.grant.refreshToken) throw new Error('no refresh token available');
+    if (entry.grant.clientSecret && entry.grant.clientSecretExpiresAt > 0
+        && entry.grant.clientSecretExpiresAt * 1000 <= Date.now()) {
+      throw new Error('OAuth dynamic client secret expired');
+    }
     if (entry.refreshPromise) return entry.refreshPromise;
     entry.refreshPromise = (async () => {
       const metadata = await discoverServerMetadata(entry.grant.issuer, config.requestTimeoutMs);
       const token = await refreshAccessToken(metadata.tokenEndpoint, {
         clientId: entry.grant.clientId,
+        clientSecret: entry.grant.clientSecret,
+        tokenEndpointAuthMethod: entry.grant.tokenEndpointAuthMethod ?? 'none',
         refreshToken: entry.grant.refreshToken,
         resource: entry.grant.authorizedResources[0],
         scope: entry.grant.scope,
@@ -204,6 +210,8 @@ export async function apply(ctx, config) {
         if (metadata.revocationEndpoint) {
           await revokeRefreshToken(metadata.revocationEndpoint, {
             clientId: entry.grant.clientId,
+            clientSecret: entry.grant.clientSecret,
+            tokenEndpointAuthMethod: entry.grant.tokenEndpointAuthMethod ?? 'none',
             refreshToken: entry.grant.refreshToken,
             timeoutMs: config.requestTimeoutMs,
           });
@@ -247,7 +255,9 @@ export async function apply(ctx, config) {
     const grantKey = record.auth.grantKey;
     const entry = grantKey ? state.grants.get(grantKey) : null;
     if (!entry) return { ok: false, kind: 'auth', serverKey: record.serverKey, serverName: record.serverName, message: 'OAuth 授权缺失，请重新授权' };
-    if (entry.needsReauth || entry.grant.accessTokenExpiresAt <= Date.now()) {
+    const clientSecretExpired = entry.grant.clientSecret && entry.grant.clientSecretExpiresAt > 0
+      && entry.grant.clientSecretExpiresAt * 1000 <= Date.now();
+    if (entry.needsReauth || clientSecretExpired || entry.grant.accessTokenExpiresAt <= Date.now()) {
       return { ok: false, kind: 'auth', serverKey: record.serverKey, serverName: record.serverName, message: 'OAuth 授权已过期或刷新失败，请重新授权' };
     }
     return null;
@@ -302,6 +312,35 @@ export async function apply(ctx, config) {
     return summary;
   }
 
+  function resolveCredentialValues(connector, params = {}) {
+    const raw = params.credentialValues && typeof params.credentialValues === 'object' && !Array.isArray(params.credentialValues)
+      ? params.credentialValues
+      : {};
+    const values = {};
+    const fields = connector.auth.credentialFields ?? [];
+    for (const [index, field] of fields.entries()) {
+      let value = raw[field.key];
+      // 兼容旧调用方：单一/首个凭据仍可通过 bearerToken 或 apiKeyValue 传入。
+      if ((value === undefined || value === '') && (field.key === 'credential' || index === 0)) {
+        value = connector.auth.mode === 'bearer' ? params.bearerToken : params.apiKeyValue;
+      }
+      if (field.required && (value === undefined || String(value).trim() === '')) {
+        throw new Error(`${field.label} 必填`);
+      }
+      if (value !== undefined && String(value) !== '') values[field.key] = String(value);
+    }
+    return values;
+  }
+
+  function bindStdioCredentials(server, credentialValues) {
+    const env = { ...(server.env ?? {}) };
+    for (const [envName, credentialKey] of Object.entries(server.credentialBindings ?? {})) {
+      const value = credentialValues[credentialKey];
+      if (value !== undefined && value !== '') env[envName] = value;
+    }
+    return env;
+  }
+
   /* ───────────────────────── api 门面 ───────────────────────── */
 
   const api = {
@@ -326,6 +365,7 @@ export async function apply(ctx, config) {
         credentialPlaceholder: d.auth.credentialPlaceholder,
         credentialDescription: d.auth.credentialDescription,
         credentialHelpLabel: d.auth.credentialHelpLabel,
+        credentialFields: d.auth.credentialFields ?? [],
         prompts: d.prompts ?? [],
         probeStatus: d.probeStatus,
         probeCheckedAt: d.probeCheckedAt,
@@ -340,6 +380,9 @@ export async function apply(ctx, config) {
         servers: (d.servers ?? []).map((s) => ({
           serverKey: s.serverKey,
           url: s.url,
+          command: s.command,
+          args: s.args,
+          credentialBindings: s.credentialBindings,
           transport: s.transport,
           serverName: s.serverName,
         })),
@@ -373,6 +416,9 @@ export async function apply(ctx, config) {
               key: grantKey,
               issuer: authz.issuer,
               clientId: authz.clientId,
+              clientSecret: authz.clientSecret,
+              clientSecretExpiresAt: authz.clientSecretExpiresAt,
+              tokenEndpointAuthMethod: authz.tokenEndpointAuthMethod ?? 'none',
               clientName: authz.clientName,
               scope: authz.scope,
               account: config.account,
@@ -466,8 +512,14 @@ export async function apply(ctx, config) {
         ok: false,
         message:
           `连接器 "${connector.name}" 需要凭据（${connector.auth.mode}），目录不含密钥。` +
-          `请用 mcp_connector_configure 提供：url=${connector.servers[0].url}, serverName=${connector.servers[0].serverName}`,
-        detail: { url: connector.servers[0].url, serverName: connector.servers[0].serverName },
+          '请用 mcp_connector_configure 在本机填写目录声明的凭据字段。',
+        detail: {
+          transport: connector.servers[0].transport,
+          url: connector.servers[0].url,
+          command: connector.servers[0].command,
+          serverName: connector.servers[0].serverName,
+          credentialFields: connector.auth.credentialFields ?? [],
+        },
       };
     },
 
@@ -481,17 +533,23 @@ export async function apply(ctx, config) {
             throw new Error(`连接器 "${connector.name}" 不是 Bearer/API Key 凭据型`);
           }
           const records = [];
+          const credentialValues = resolveCredentialValues(connector, params);
+          const primaryCredential = credentialValues[connector.auth.credentialFields?.[0]?.key ?? 'credential'];
           for (const server of connector.servers) {
             const record = buildManualRecord({
               name: connector.servers.length > 1 ? `${connector.name}·${server.serverKey}` : connector.name,
               url: server.url,
               serverName: server.serverName,
               transport: server.transport,
+              command: server.command,
+              args: server.args,
+              envJson: server.transport === 'stdio' ? bindStdioCredentials(server, credentialValues) : undefined,
+              cwd: server.cwd,
               headersJson: server.headers,
-              authMode: connector.auth.mode,
-              bearerToken: params.bearerToken,
+              authMode: server.transport === 'stdio' ? 'none' : connector.auth.mode,
+              bearerToken: params.bearerToken ?? primaryCredential,
               apiKeyHeader: params.apiKeyHeader || connector.auth.apiKeyHeader,
-              apiKeyValue: params.apiKeyValue,
+              apiKeyValue: params.apiKeyValue ?? primaryCredential,
             });
             record.key = `${connector.id}-${server.serverKey}`;
             record.connectorId = connector.id;
@@ -727,6 +785,8 @@ export async function apply(ctx, config) {
               if (metadata.revocationEndpoint) {
                 await revokeRefreshToken(metadata.revocationEndpoint, {
                   clientId: g.grant.clientId,
+                  clientSecret: g.grant.clientSecret,
+                  tokenEndpointAuthMethod: g.grant.tokenEndpointAuthMethod ?? 'none',
                   refreshToken: g.grant.refreshToken,
                   timeoutMs: config.requestTimeoutMs,
                 });

package/lib/oauth.js

@@ -184,7 +184,13 @@ export async function discoverServerMetadata(issuer, timeoutMs) {
 
 /* ─────────────────────────── 阶段三：动态注册客户端 ─────────────────────────── */
 
-export async function registerClient(registrationEndpoint, { clientName, redirectUris, scope = DEFAULT_SCOPE, timeoutMs }) {
+export async function registerClient(registrationEndpoint, {
+  clientName,
+  redirectUris,
+  scope = DEFAULT_SCOPE,
+  tokenEndpointAuthMethod = 'none',
+  timeoutMs,
+}) {
   if (!Array.isArray(redirectUris) || redirectUris.length === 0) {
     throw new OAuthError('invalid_client_metadata', 'redirect_uris is required');
   }
@@ -198,7 +204,7 @@ export async function registerClient(registrationEndpoint, { clientName, redirec
         redirect_uris: redirectUris,
         grant_types: ['authorization_code', 'refresh_token'],
         response_types: ['code'],
-        token_endpoint_auth_method: 'none',
+        token_endpoint_auth_method: tokenEndpointAuthMethod,
         scope,
       }),
     },
@@ -207,7 +213,25 @@ export async function registerClient(registrationEndpoint, { clientName, redirec
   if (typeof body.client_id !== 'string' || body.client_id.length === 0) {
     throw new OAuthError('invalid_client_metadata', 'registration response missing client_id');
   }
-  return { clientId: body.client_id, clientIdIssuedAt: body.client_id_issued_at, clientName: body.client_name };
+  const resolvedAuthMethod = body.token_endpoint_auth_method ?? tokenEndpointAuthMethod;
+  if (!['none', 'client_secret_post', 'client_secret_basic'].includes(resolvedAuthMethod)) {
+    throw new OAuthError('invalid_client_metadata', `unsupported token_endpoint_auth_method: ${resolvedAuthMethod}`);
+  }
+  const clientSecret = typeof body.client_secret === 'string' && body.client_secret.length > 0
+    ? body.client_secret
+    : undefined;
+  if (resolvedAuthMethod !== 'none' && !clientSecret) {
+    throw new OAuthError('invalid_client_metadata', `registration response missing client_secret for ${resolvedAuthMethod}`);
+  }
+  const expiresAt = Number(body.client_secret_expires_at);
+  return {
+    clientId: body.client_id,
+    clientSecret,
+    clientSecretExpiresAt: Number.isFinite(expiresAt) ? expiresAt : undefined,
+    tokenEndpointAuthMethod: resolvedAuthMethod,
+    clientIdIssuedAt: body.client_id_issued_at,
+    clientName: body.client_name,
+  };
 }
 
 /* ─────────────────────────── PKCE ─────────────────────────── */
@@ -250,10 +274,43 @@ export function buildAuthorizeUrl(metadata, { clientId, redirectUri, state, chal
 
 /* ─────────────────────────── 阶段五：换 token / 刷新 / 撤销 ─────────────────────────── */
 
-export async function exchangeCode(tokenEndpoint, { clientId, code, redirectUri, codeVerifier, resource, scope, timeoutMs }) {
+function formComponent(value) {
+  return new URLSearchParams({ value: String(value) }).toString().slice('value='.length);
+}
+
+function clientAuthentication({ clientId, clientSecret, tokenEndpointAuthMethod = 'none' }) {
+  if (!clientId) throw new OAuthError('invalid_client', 'client_id is required');
+  if (tokenEndpointAuthMethod === 'none') {
+    return { params: { client_id: clientId }, headers: {} };
+  }
+  if (!clientSecret) {
+    throw new OAuthError('invalid_client', `client_secret is required for ${tokenEndpointAuthMethod}`);
+  }
+  if (tokenEndpointAuthMethod === 'client_secret_post') {
+    return { params: { client_id: clientId, client_secret: clientSecret }, headers: {} };
+  }
+  if (tokenEndpointAuthMethod === 'client_secret_basic') {
+    const encoded = Buffer.from(`${formComponent(clientId)}:${formComponent(clientSecret)}`).toString('base64');
+    return { params: {}, headers: { Authorization: `Basic ${encoded}` } };
+  }
+  throw new OAuthError('invalid_client', `unsupported token endpoint auth method: ${tokenEndpointAuthMethod}`);
+}
+
+export async function exchangeCode(tokenEndpoint, {
+  clientId,
+  clientSecret,
+  tokenEndpointAuthMethod = 'none',
+  code,
+  redirectUri,
+  codeVerifier,
+  resource,
+  scope,
+  timeoutMs,
+}) {
+  const clientAuth = clientAuthentication({ clientId, clientSecret, tokenEndpointAuthMethod });
   const params = {
     grant_type: 'authorization_code',
-    client_id: clientId,
+    ...clientAuth.params,
     code,
     redirect_uri: redirectUri,
     code_verifier: codeVerifier,
@@ -262,37 +319,53 @@ export async function exchangeCode(tokenEndpoint, { clientId, code, redirectUri,
   if (scope) params.scope = scope;
   const body = await fetchJson(
     tokenEndpoint,
-    { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: formEncode(params) },
+    { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded', ...clientAuth.headers }, body: formEncode(params) },
     timeoutMs,
   );
   return parseTokenResponse(body, scope);
 }
 
-export async function refreshAccessToken(tokenEndpoint, { clientId, refreshToken, resource, scope, timeoutMs }) {
+export async function refreshAccessToken(tokenEndpoint, {
+  clientId,
+  clientSecret,
+  tokenEndpointAuthMethod = 'none',
+  refreshToken,
+  resource,
+  scope,
+  timeoutMs,
+}) {
+  const clientAuth = clientAuthentication({ clientId, clientSecret, tokenEndpointAuthMethod });
   const params = {
     grant_type: 'refresh_token',
-    client_id: clientId,
+    ...clientAuth.params,
     refresh_token: refreshToken,
   };
   if (resource) params.resource = resource;
   if (scope) params.scope = scope;
   const body = await fetchJson(
     tokenEndpoint,
-    { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: formEncode(params) },
+    { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded', ...clientAuth.headers }, body: formEncode(params) },
     timeoutMs,
   );
   return parseTokenResponse(body, scope);
 }
 
-export async function revokeRefreshToken(revocationEndpoint, { clientId, refreshToken, timeoutMs }) {
+export async function revokeRefreshToken(revocationEndpoint, {
+  clientId,
+  clientSecret,
+  tokenEndpointAuthMethod = 'none',
+  refreshToken,
+  timeoutMs,
+}) {
+  const clientAuth = clientAuthentication({ clientId, clientSecret, tokenEndpointAuthMethod });
   assertSafeUrl(revocationEndpoint);
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(new Error('timeout')), timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
   try {
     const response = await fetch(revocationEndpoint, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-      body: formEncode({ client_id: clientId, token: refreshToken, token_type_hint: 'refresh_token' }),
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded', ...clientAuth.headers },
+      body: formEncode({ ...clientAuth.params, token: refreshToken, token_type_hint: 'refresh_token' }),
       signal: controller.signal,
     });
     if (response.ok) return true;

package/lib/schema.js

@@ -11,12 +11,24 @@ export const serverRefSchema = z.object({
   command: z.string().min(1).optional(),
   args: z.array(z.string()).optional(),
   env: z.record(z.string()).optional(),
+  credentialBindings: z.record(z.string()).optional(),
   cwd: z.string().optional(),
   serverName: z.string().min(1),
   transport: z.enum(['streamable-http', 'sse', 'stdio']).optional(),
   headers: z.record(z.string()).optional(),
 });
 
+/** 市场凭据输入定义；只描述表单，绝不包含真实值。 */
+export const credentialFieldSchema = z.object({
+  key: z.string().regex(/^[A-Za-z][A-Za-z0-9_-]*$/, '仅允许字母开头及字母/数字/_/-'),
+  label: z.string().min(1),
+  placeholder: z.string().optional(),
+  description: z.string().optional(),
+  helpLabel: z.string().optional(),
+  required: z.boolean().optional(),
+  secret: z.boolean().optional(),
+});
+
 /** Prompt 模板变量；目录只描述表单，不保存用户输入。 */
 export const promptVariableSchema = z.object({
   name: z.string().regex(/^[A-Za-z][A-Za-z0-9_-]*$/, '仅允许字母开头及字母/数字/_/-'),
@@ -71,13 +83,14 @@ export const connectorDescriptorSchema = z.object({
       issuer: z.string().optional(),
       scope: z.string().optional(),
       clientName: z.string().optional(),
-      tokenEndpointAuthMethod: z.string().optional(),
+      tokenEndpointAuthMethod: z.enum(['none', 'client_secret_post', 'client_secret_basic']).optional(),
       apiKeyHeader: z.string().optional(),
       grantSharing: z.string().optional(),
       credentialName: z.string().optional(),
       credentialPlaceholder: z.string().optional(),
       credentialDescription: z.string().optional(),
       credentialHelpLabel: z.string().optional(),
+      credentialFields: z.array(credentialFieldSchema).optional(),
     })
     .optional(),
   servers: z.array(serverRefSchema).min(1),
@@ -118,6 +131,9 @@ export const grantRecordSchema = z.object({
   key: z.string().min(1),
   issuer: z.string().min(1),
   clientId: z.string().min(1),
+  clientSecret: z.string().optional(),
+  clientSecretExpiresAt: z.number().optional(),
+  tokenEndpointAuthMethod: z.enum(['none', 'client_secret_post', 'client_secret_basic']).optional(),
   clientName: z.string().optional(),
   scope: z.string(),
   account: z.string(),
@@ -160,12 +176,37 @@ export function normalizeConnectorDescriptor(raw) {
       command: transport === 'stdio' ? s.command : undefined,
       args: transport === 'stdio' ? (s.args ?? []) : undefined,
       env: transport === 'stdio' ? (s.env ?? {}) : undefined,
+      credentialBindings: transport === 'stdio' ? (s.credentialBindings ?? {}) : undefined,
       cwd: transport === 'stdio' ? (s.cwd ?? '') : undefined,
       serverName: s.serverName,
       transport,
       headers: transport === 'streamable-http' ? (s.headers ?? {}) : {},
     };
   });
+  const authMode = c.auth?.mode ?? 'none';
+  const fallbackCredentialLabel = c.auth?.credentialName
+    || (authMode === 'bearer' ? 'Bearer Token' : authMode === 'api-key' ? 'API Key' : '凭据');
+  const credentialFields = c.auth?.credentialFields?.length
+    ? c.auth.credentialFields.map((field) => ({
+        key: field.key,
+        label: field.label,
+        placeholder: field.placeholder ?? '',
+        description: field.description ?? '',
+        helpLabel: field.helpLabel ?? '',
+        required: field.required !== false,
+        secret: field.secret !== false,
+      }))
+    : ['bearer', 'api-key'].includes(authMode)
+      ? [{
+          key: 'credential',
+          label: fallbackCredentialLabel,
+          placeholder: c.auth?.credentialPlaceholder ?? '',
+          description: c.auth?.credentialDescription ?? '',
+          helpLabel: c.auth?.credentialHelpLabel ?? '',
+          required: true,
+          secret: true,
+        }]
+      : [];
   return {
     schemaVersion: c.schemaVersion ?? 1,
     id: c.id,
@@ -186,7 +227,7 @@ export function normalizeConnectorDescriptor(raw) {
     probeReportUrl: c.probeReportUrl ?? '',
     toolsSnapshot: c.toolsSnapshot ?? [],
     auth: {
-      mode: c.auth?.mode ?? 'none',
+      mode: authMode,
       issuer: c.auth?.issuer ?? '',
       scope: c.auth?.scope ?? 'mcp:tools',
       clientName: c.auth?.clientName ?? 'DeepSeek Harness - MCP 连接器',
@@ -197,6 +238,7 @@ export function normalizeConnectorDescriptor(raw) {
       credentialPlaceholder: c.auth?.credentialPlaceholder ?? '',
       credentialDescription: c.auth?.credentialDescription ?? '',
       credentialHelpLabel: c.auth?.credentialHelpLabel ?? '',
+      credentialFields,
     },
     servers,
   };

package/lib/tools.js

@@ -61,9 +61,46 @@ const statusOutput = {
 
 const noArgs = { type: 'object', properties: {}, additionalProperties: false };
 
+/**
+ * DSH tools require a lossless JSON value at the execute boundary. Normalize
+ * values that JSON.stringify would otherwise drop or rewrite, and always emit
+ * plain objects so transport-specific undefined fields cannot reject a tool
+ * result on stricter Desktop hosts.
+ */
+export function toLossless(value, seen = new Set()) {
+  if (value === null) return null;
+  const type = typeof value;
+  if (type === 'string' || type === 'boolean') return value;
+  if (type === 'number') {
+    if (!Number.isFinite(value)) return null;
+    return Object.is(value, -0) ? 0 : value;
+  }
+  if (type === 'undefined' || type === 'function' || type === 'symbol' || type === 'bigint') return null;
+  if (type !== 'object' || seen.has(value)) return null;
+
+  seen.add(value);
+  let output;
+  if (Array.isArray(value)) {
+    output = [];
+    for (let index = 0; index < value.length; index += 1) {
+      output[index] = Object.hasOwn(value, index) ? toLossless(value[index], seen) : null;
+    }
+  } else {
+    output = {};
+    for (const key of Object.keys(value)) output[key] = toLossless(value[key], seen);
+  }
+  seen.delete(value);
+  return output;
+}
+
 export function registerTools(ctx, api) {
   const disposers = [];
-  const reg = (def) => disposers.push(ctx.tools.register(def));
+  const reg = (def) => disposers.push(ctx.tools.register({
+    ...def,
+    async execute(args, exec) {
+      return toLossless(await def.execute(args, exec));
+    },
+  }));
 
   reg({
     name: 'mcp_connector_catalog',
@@ -109,7 +146,8 @@ export function registerTools(ctx, api) {
     name: 'mcp_connector_configure',
     description:
       '自定义配置一个外部 MCP Server 连接：HTTP 可填写 URL/鉴权；stdio 可填写 command/args/env/cwd。' +
-      '也可对市场中的 Bearer/API Key 连接器按 connectorId 一次配置全部 Server；市场连接器会先验证 initialize 连通性与凭据，通过后才保存。',
+      '也可对市场中的 Bearer/API Key 连接器按 connectorId 一次配置全部 Server；stdio 凭据会按目录声明安全注入本机环境变量。' +
+      '市场连接器会先验证或交由 Host 托管，通过后才保存。',
     parameters: {
       type: 'object',
       properties: {
@@ -126,6 +164,11 @@ export function registerTools(ctx, api) {
         bearerToken: { type: 'string', description: 'authMode=bearer 时的 token' },
         apiKeyHeader: { type: 'string', description: 'authMode=api-key 时的头名，默认 X-Api-Key' },
         apiKeyValue: { type: 'string', description: 'authMode=api-key 时的值' },
+        credentialValues: {
+          type: 'object',
+          additionalProperties: { type: 'string' },
+          description: '市场 stdio 连接器声明的凭据字段值；只保存在本机，不写入目录',
+        },
         headersJson: { type: 'string', description: '额外静态头（JSON 对象字符串）' },
       },
       anyOf: [{ required: ['connectorId'] }, { required: ['name', 'url'] }, { required: ['name', 'transport', 'command'] }],

package/lib/web.js

@@ -9,7 +9,7 @@
  * 本模块只依赖 ctx.webServer / ctx.webRuntime；在非 web 部署（无这两个服务）时
  * 调用方应跳过挂载，保证插件仍可用于纯对话工具场景。
  */
-import { dirname, join, normalize, relative, resolve } from 'node:path';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 
@@ -131,20 +131,26 @@ function extOf(pathname) {
 }
 
 /** 把 URL pathname 安全地映射到 ui 目录内的文件（防目录穿越）。 */
-function resolveUiFile(pathname) {
-  let rel;
+export function splitUiPath(pathname) {
+  let decoded;
   try {
-    rel = decodeURIComponent(pathname);
+    decoded = decodeURIComponent(pathname);
   } catch {
-    return { ok: false };
+    return undefined;
   }
-  rel = normalize(rel.replace(/\\/g, '/')).replace(/^\/+/, '');
-  if (rel === '.' || rel === '') return { ok: true, path: join(UI_DIR, 'index.html'), rel: 'index.html' };
-  if (rel.startsWith('..')) return { ok: false };
-  const abs = resolve(UI_DIR, rel);
+  const segments = decoded.replace(/\\/g, '/').split('/').filter((segment) => segment !== '' && segment !== '.');
+  if (segments.includes('..')) return undefined;
+  return segments;
+}
+
+export function resolveUiFile(pathname) {
+  const segments = splitUiPath(pathname);
+  if (segments === undefined) return { ok: false };
+  if (segments.length === 0) return { ok: true, path: join(UI_DIR, 'index.html'), rel: 'index.html' };
+  const abs = resolve(UI_DIR, ...segments);
   const relAbs = relative(UI_DIR, abs);
-  if (relAbs.startsWith('..') || relAbs === '') return { ok: false };
-  return { ok: true, path: abs, rel: relAbs };
+  if (relAbs === '..' || relAbs.startsWith(`..${sep}`) || isAbsolute(relAbs) || relAbs === '') return { ok: false };
+  return { ok: true, path: abs, rel: segments.join('/') };
 }
 
 /* ───────────────────────── 路由挂载 ───────────────────────── */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mcp-connector",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "description": "General-purpose MCP connector, connection manager, plugin extension, and integration marketplace for DeepSeek Harness, initiated and maintained by Qichacha/QCC.",
   "type": "module",
   "main": "lib/index.js",

package/registry/catalog.json

@@ -79,7 +79,18 @@
         "credentialName": "北大法宝 Access Token",
         "credentialPlaceholder": "请输入您的北大法宝 Access Token",
         "credentialDescription": "用于访问北大法宝 MCP；仅保存在 DSH 本机。",
-        "credentialHelpLabel": "如何获取北大法宝 Token？"
+        "credentialHelpLabel": "如何获取北大法宝 Token？",
+        "credentialFields": [
+          {
+            "key": "credential",
+            "label": "北大法宝 Access Token",
+            "placeholder": "请输入您的北大法宝 Access Token",
+            "description": "用于访问北大法宝 MCP；仅保存在 DSH 本机。",
+            "helpLabel": "如何获取北大法宝 Token？",
+            "required": true,
+            "secret": true
+          }
+        ]
       },
       "servers": [
         {
@@ -211,7 +222,18 @@
         "credentialName": "Wind API Key（个人密钥）",
         "credentialPlaceholder": "请输入您的个人 Wind API Key",
         "credentialDescription": "用于访问 Wind MCP 的个人访问令牌；仅保存在 DSH 本机。",
-        "credentialHelpLabel": "如何获取 Wind API Key？"
+        "credentialHelpLabel": "如何获取 Wind API Key？",
+        "credentialFields": [
+          {
+            "key": "credential",
+            "label": "Wind API Key（个人密钥）",
+            "placeholder": "请输入您的个人 Wind API Key",
+            "description": "用于访问 Wind MCP 的个人访问令牌；仅保存在 DSH 本机。",
+            "helpLabel": "如何获取 Wind API Key？",
+            "required": true,
+            "secret": true
+          }
+        ]
       },
       "servers": [
         {

package/registry/connectors/stdio-credential.sample.json

@@ -0,0 +1,50 @@
+{
+  "schemaVersion": 1,
+  "id": "vendor-local-service",
+  "name": "厂商·本地 MCP 示例",
+  "vendor": "厂商名称",
+  "icon": "🔐",
+  "category": "开发工具",
+  "summary": "演示市场凭据如何安全注入 stdio 环境变量",
+  "description": "目录只声明输入字段和环境变量映射；用户填写的真实值仅保存在 DSH 本机。",
+  "published": false,
+  "featured": false,
+  "homepage": "https://example.com/mcp",
+  "probeStatus": "unverified",
+  "auth": {
+    "mode": "api-key",
+    "credentialFields": [
+      {
+        "key": "apiToken",
+        "label": "服务 API Token",
+        "placeholder": "仅保存在 DSH 本机",
+        "description": "从服务控制台创建，不得提交到目录。",
+        "required": true,
+        "secret": true
+      },
+      {
+        "key": "region",
+        "label": "区域",
+        "placeholder": "例如 cn-east-1",
+        "required": true,
+        "secret": false
+      }
+    ]
+  },
+  "servers": [
+    {
+      "serverKey": "main",
+      "serverName": "vendor-local-service",
+      "transport": "stdio",
+      "command": "npx",
+      "args": ["-y", "@vendor/example-mcp-server"],
+      "env": {
+        "LOG_LEVEL": "info"
+      },
+      "credentialBindings": {
+        "VENDOR_API_TOKEN": "apiToken",
+        "VENDOR_REGION": "region"
+      }
+    }
+  ]
+}

package/registry/schema/connector.schema.json

@@ -30,13 +30,17 @@
         "issuer": { "type": "string" },
         "scope": { "type": "string" },
         "clientName": { "type": "string" },
-        "tokenEndpointAuthMethod": { "type": "string" },
+        "tokenEndpointAuthMethod": { "enum": ["none", "client_secret_post", "client_secret_basic"] },
         "apiKeyHeader": { "type": "string" },
         "grantSharing": { "type": "string" },
         "credentialName": { "type": "string" },
         "credentialPlaceholder": { "type": "string" },
         "credentialDescription": { "type": "string" },
-        "credentialHelpLabel": { "type": "string" }
+        "credentialHelpLabel": { "type": "string" },
+        "credentialFields": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/credentialField" }
+        }
       }
     },
     "servers": {
@@ -52,6 +56,7 @@
           "command": { "type": "string", "minLength": 1 },
           "args": { "type": "array", "items": { "type": "string" } },
           "env": { "type": "object", "additionalProperties": { "type": "string" } },
+          "credentialBindings": { "type": "object", "additionalProperties": { "type": "string" } },
           "cwd": { "type": "string" },
           "serverName": { "type": "string", "minLength": 1 },
           "transport": { "enum": ["streamable-http", "stdio"] },
@@ -106,6 +111,20 @@
     }
   },
   "$defs": {
+    "credentialField": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["key", "label"],
+      "properties": {
+        "key": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_-]*$" },
+        "label": { "type": "string", "minLength": 1 },
+        "placeholder": { "type": "string" },
+        "description": { "type": "string" },
+        "helpLabel": { "type": "string" },
+        "required": { "type": "boolean" },
+        "secret": { "type": "boolean" }
+      }
+    },
     "variables": {
       "type": "array",
       "items": {

package/ui/index.html

@@ -924,15 +924,31 @@
   function openCatalogCredentialForm(preset) {
     const authMode = preset.authMode === 'api-key' ? 'api-key' : 'bearer';
     const servers = preset.servers || [];
+    const usesStdio = servers.some((server) => server.transport === 'stdio');
     const homepage = /^https:\/\//i.test(preset.homepage || '') ? preset.homepage : '';
     const credentialName = preset.credentialName || (authMode === 'bearer' ? 'Bearer Token' : 'API Key');
     const credentialPlaceholder = preset.credentialPlaceholder || '仅保存在 DSH 本机';
     const credentialDescription = preset.credentialDescription || '凭据仅保存在 DSH 本机，不会写入市场目录或对话。';
     const credentialHelpLabel = preset.credentialHelpLabel || `前往 ${preset.vendor || preset.name} 官网获取`;
-    const credentialFields = authMode === 'bearer'
-      ? `<label for="cfg-token">${esc(credentialName)}（必填）</label><input id="cfg-token" type="password" autocomplete="off" placeholder="${esc(credentialPlaceholder)}" /><div class="field-help">${esc(credentialDescription)}</div>`
-      : `<div class="form-row"><div><label for="cfg-key-header">API Key Header</label><input id="cfg-key-header" value="${esc(preset.apiKeyHeader || 'X-Api-Key')}" /></div><div><label for="cfg-key-value">${esc(credentialName)}（必填）</label><input id="cfg-key-value" type="password" autocomplete="off" placeholder="${esc(credentialPlaceholder)}" /></div></div><div class="field-help">${esc(credentialDescription)}</div>`;
-    const serverPreview = servers.map((server) => `<div>${esc(server.serverName)} · ${esc(server.url)}</div>`).join('');
+    const declaredFields = preset.credentialFields?.length ? preset.credentialFields : [{
+      key: 'credential', label: credentialName, placeholder: credentialPlaceholder,
+      description: credentialDescription, required: true, secret: true,
+    }];
+    const stdioCredentialFields = declaredFields.map((field) => {
+      const id = `cfg-credential-${field.key}`;
+      return `<label for="${esc(id)}">${esc(field.label)}${field.required === false ? '（可选）' : '（必填）'}</label><input id="${esc(id)}" data-credential-key="${esc(field.key)}" type="${field.secret === false ? 'text' : 'password'}" autocomplete="off" placeholder="${esc(field.placeholder || '仅保存在 DSH 本机')}" />${field.description ? `<div class="field-help">${esc(field.description)}</div>` : ''}`;
+    }).join('');
+    const credentialFields = usesStdio
+      ? stdioCredentialFields
+      : authMode === 'bearer'
+        ? `<label for="cfg-token">${esc(credentialName)}（必填）</label><input id="cfg-token" type="password" autocomplete="off" placeholder="${esc(credentialPlaceholder)}" /><div class="field-help">${esc(credentialDescription)}</div>`
+        : `<div class="form-row"><div><label for="cfg-key-header">API Key Header</label><input id="cfg-key-header" value="${esc(preset.apiKeyHeader || 'X-Api-Key')}" /></div><div><label for="cfg-key-value">${esc(credentialName)}（必填）</label><input id="cfg-key-value" type="password" autocomplete="off" placeholder="${esc(credentialPlaceholder)}" /></div></div><div class="field-help">${esc(credentialDescription)}</div>`;
+    const serverPreview = servers.map((server) => {
+      const endpoint = server.transport === 'stdio'
+        ? `stdio · ${server.command || ''} ${(server.args || []).join(' ')}`.trim()
+        : server.url;
+      return `<div>${esc(server.serverName)} · ${esc(endpoint)}</div>`;
+    }).join('');
     openModal(`配置 ${preset.name}`, `
       <input id="cfg-connector-id" type="hidden" value="${esc(preset.id)}" />
       <input id="cfg-auth" type="hidden" value="${esc(authMode)}" />
@@ -1067,10 +1083,15 @@
       const connectorId = $('#cfg-connector-id')?.value.trim();
       const authMode = $('#cfg-auth').value;
       if (connectorId) {
+        const credentialValues = {};
+        document.querySelectorAll('[data-credential-key]').forEach((input) => {
+          credentialValues[input.dataset.credentialKey] = input.value;
+        });
         setModalBusy(true, '正在验证凭据与连接…');
         const r = await call('configure', {
           connectorId,
           authMode,
+          credentialValues,
           bearerToken: $('#cfg-token')?.value || undefined,
           apiKeyHeader: $('#cfg-key-header')?.value || undefined,
           apiKeyValue: $('#cfg-key-value')?.value || undefined,