dsh-mcp-connector 0.2.33 → 0.2.35

package/CHANGELOG.md

@@ -4,6 +4,27 @@
 
 ## [Unreleased]
 
+## [0.2.35] - 2026-09-05
+
+### Fixed
+
+- 市场详情内完成免密连接、凭据配置或 OAuth 重新授权后，现在会原地重新读取连接状态与工具清单，并同步启用 Prompt 和试用按钮；用户在刷新期间主动关闭或切换详情时不会被强制重新打开。
+
+### Verification
+
+- 195 项自动测试、lint、版本/营销元数据/商店截图门禁和 npm 发布包白名单/敏感内容扫描全部通过。
+
+## [0.2.34] - 2026-09-04
+
+### Added
+
+- 用户自建连接可对 RFC1918 IPv4 / RFC4193 IPv6 ULA 字面量显式授权明文 HTTP；默认仍拒绝，公网 HTTP、域名、链路本地与元数据地址不受该开关影响。
+
+### Fixed
+
+- OAuth 一键连接现在标记资源发现、服务发现、回调监听、客户端注册、授权回调和 Token 换取阶段；DCR HTTP 403 会明确说明服务商客户端准入限制，不再误导为用户授权或凭据问题。
+- OAuth 在动态客户端注册等浏览器打开前的阶段失败时，会立即关闭本机回调监听，避免遗留端口与超时任务。
+
 ## [0.2.33] - 2026-09-04
 
 ### Added
@@ -527,7 +548,11 @@
 - 外部 URL 与导入 Header 执行安全校验。
 - iframe 消息校验同源和消息来源。
 
-[Unreleased]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.31...HEAD
+[Unreleased]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.35...HEAD
+[0.2.35]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.34...v0.2.35
+[0.2.34]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.33...v0.2.34
+[0.2.33]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.32...v0.2.33
+[0.2.32]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.31...v0.2.32
 [0.2.31]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.30...v0.2.31
 [0.2.30]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.29...v0.2.30
 [0.2.29]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.28...v0.2.29

package/README.en.md

@@ -66,7 +66,7 @@ If the plugin helps you connect an MCP server faster, consider [starring the rep
 - Explicit, non-destructive migration from the two earlier Qichacha OAuth plugins, plus active-plugin conflict detection that blocks duplicate server management and credential overwrites.
 
 <!-- catalog-stats:start -->
-As of 2026-09-02, the public Registry publishes 101 connector descriptors. After merging and deduplicating them with the 4 bundled Qichacha cards, the Marketplace exposes 105 cards across 9 business categories. Recommendations remain limited to the four Qichacha cards, PKULaw, and Wind, for 6 featured cards in total. The Registry evolves independently; the badge shown after a client refresh and the live badges above are the authoritative current counts.
+As of 2026-09-04, the public Registry publishes 100 connector descriptors. After merging and deduplicating them with the 4 bundled Qichacha cards, the Marketplace exposes 104 cards across 9 business categories. Recommendations remain limited to the four Qichacha cards, PKULaw, and Wind, for 6 featured cards in total. The Registry evolves independently; the badge shown after a client refresh and the live badges above are the authoritative current counts.
 <!-- catalog-stats:end -->
 
 ## Interface and demo
@@ -171,7 +171,7 @@ npm run dev:ui
 
 Every Registry merge regenerates `catalog-stats.json`; an hourly workflow in this repository synchronizes the Chinese and English product copy plus a local stats snapshot. The static npm README updates with package releases, while the live badges above read the Registry directly and therefore stay current without another npm release.
 
-The current public version is [`dsh-mcp-connector@0.2.33`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.33](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.33).
+The current public version is [`dsh-mcp-connector@0.2.35`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.35](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.35).
 
 See [CHANGELOG.md](CHANGELOG.md) for version history and [docs/DESKTOP-E2E.md](docs/DESKTOP-E2E.md) for the Desktop release checklist.
 
@@ -180,11 +180,12 @@ See [CHANGELOG.md](CHANGELOG.md) for version history and [docs/DESKTOP-E2E.md](d
 - Credentials stay inside the local DSH storage boundary: connection records use the storage domain, while rotating OAuth credentials are also saved in `$DSH_HOME/storages/mcp_connector_grants_v1` so stale host snapshots cannot overwrite them. The directory is mode 0700 and records are mode 0600; credentials are never written to the catalog, Git repository, page, logs, or conversation history.
 - Failed API key/token validation is not persisted; authentication, timeout, DNS, and TLS/network errors are reported separately.
 - Unchecked or Host-unobservable connections are reported as `unknown`, never as healthy. Health history and last-success timestamps are currently process-local.
-- External URLs must use HTTPS; HTTP is allowed only for loopback development.
+- External URLs use HTTPS by default, and HTTP is allowed for loopback development. A user-created connection may explicitly opt in to plaintext HTTP for literal RFC1918 IPv4 or RFC4193 IPv6 ULA addresses; hostnames, public HTTP, link-local addresses, and cloud metadata addresses remain blocked.
 - 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 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.
+- OAuth failures identify resource discovery, server discovery, client registration, browser callback, or token exchange. A DCR HTTP 403 is reported as provider-side client admission rejection rather than a missing user authorization.
 - Redacted exports replace tokens, API keys, static header/env values, stdio arguments, local directories, and URLs containing query/user information with explicit placeholders. OAuth entries contain only a reconnect reference; full snapshots remain inside the current profile's storage domain.
 - The primary sidebar placement uses the stable DSH `data-slot` marker and falls back to the footer if that marker is removed.
 - Project/global scopes apply only inside the current DSH profile and do not synchronize across profiles. If a Workspace is deleted, its project-only bindings remain fail-closed until moved to another project or global.

package/README.md

@@ -68,7 +68,7 @@ dsh plugin --profile web add dsh-mcp-connector
 - 对话工具：`mcp_connector_catalog`、`connect`、`configure`、`import_json`、`export_config`、`snapshot`、`install_from_url`、`status`、`scope`、`health_check`、`policy`、`set_enabled`、`disconnect`、`refresh_catalog`、`publish`、`tools_list`。
 
 <!-- catalog-stats:start -->
-截至 2026-09-02，公共 Registry 已发布 101 条连接器描述；与随包的 4 张企查查卡片合并去重后，市场页可浏览 105 张卡片，覆盖企业数据、金融投资、法律合规、开发工具、办公协作、调研分析、设计创意、效率工具、其他 9 类。推荐位严格保留 4 张企查查卡片、北大法宝和 Wind，共 6 张；其他连接器按业务分类展示。Registry 可独立持续更新，实际数量以客户端刷新后的市场页签徽标和上方实时统计徽标为准。
+截至 2026-09-04，公共 Registry 已发布 100 条连接器描述；与随包的 4 张企查查卡片合并去重后，市场页可浏览 104 张卡片，覆盖企业数据、金融投资、法律合规、开发工具、办公协作、调研分析、设计创意、效率工具、其他 9 类。推荐位严格保留 4 张企查查卡片、北大法宝和 Wind，共 6 张；其他连接器按业务分类展示。Registry 可独立持续更新，实际数量以客户端刷新后的市场页签徽标和上方实时统计徽标为准。
 <!-- catalog-stats:end -->
 
 ## 界面与演示
@@ -167,7 +167,7 @@ npm run dev:ui
 
 公共 Registry 每次合并后会生成 `catalog-stats.json`；本仓库的定时工作流每小时同步中英文介绍和统计快照。npm 页面中的静态正文随版本发布更新，上方动态统计徽标则直接读取 Registry，可在不发布新 npm 版本时保持实时数量一致。
 
-当前公开版本为 [`dsh-mcp-connector@0.2.33`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.33](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.33)。
+当前公开版本为 [`dsh-mcp-connector@0.2.35`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.35](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.35)。
 
 版本能力与变更记录见 [CHANGELOG.md](CHANGELOG.md)。
 Desktop 发版回归见 [docs/DESKTOP-E2E.md](docs/DESKTOP-E2E.md)。
@@ -180,11 +180,12 @@ stdio 传输的架构、透传边界与安全约束见 [docs/STDIO-SUPPORT.md](d
 - 凭证只持久化在本机 DSH storage 边界：连接记录使用 storage domain，OAuth 轮换凭据同步保存到 `$DSH_HOME/storages/mcp_connector_grants_v1`。该目录为 0700、文件为 0600；凭证不进入市场目录、Git 仓库、页面、日志或对话历史。
 - 市场 Key/Token 校验失败时不写入 storage domain；鉴权、超时、DNS、TLS/网络错误会分类提示。
 - 未检查或 Host 状态不可见时显示“状态未知”，不会冒充健康；健康摘要与最近成功时间当前只保留在插件进程内。
-- 外部 URL 仅允许 HTTPS，HTTP 仅允许回环地址；导入配置会校验 URL 与 Header。
+- 外部 URL 默认仅允许 HTTPS，HTTP 默认仅允许回环地址。用户自建连接可在明确风险确认后放行 RFC1918 IPv4 / RFC4193 IPv6 ULA 字面量；域名、公网 HTTP、链路本地与云元数据地址仍拒绝。
 - 远程目录/描述响应限制 2 MiB，Web API 请求限制 1 MiB；原始 JSON 在归一化前扫描凭据字段。
 - 完整覆盖 Streamable HTTP 与 stdio；旧 `sse` 配置在导入/恢复时归一为 Streamable HTTP。stdio 的 `command/args/env/cwd` 原样交给 `@deepseek-ai/dsh-mcp-client`，插件本身不重复实现进程传输。
 - stdio 会启动本机进程：仅导入或连接可信命令/软件包。市场目录只能用 `credentialFields` + `credentialBindings` 声明输入与 env 映射，不得携带真实 token/secret；用户填写值只写入本机连接记录并交给 Host。
 - OAuth DCR 的 `client_secret` 与 Access/Refresh Token 采用相同的本机存储边界，不会进入市场 API、状态输出或日志。
+- OAuth 连接失败会标明资源发现、服务发现、客户端注册、授权回调或 Token 换取阶段；DCR HTTP 403 表示服务商拒绝未准入客户端，不是用户未点击授权。
 - 脱敏导出把 Token/API Key、静态 Header/env 值、stdio 参数、本地目录及带查询参数的 URL 替换为占位符；OAuth 只保留重新授权引用。快照中的完整配置仍只在当前 profile 的 storage domain 内。
 - 顶部入口通过 DSH 稳定 `data-slot` 定位并使用 React Portal；DSH 若移除该标记，入口会回退到底部，不影响连接器功能。
 - 旧授权迁移必须显式确认，只复制不删除；确认新连接可用后再手动停用旧插件。

package/docs/USER-GUIDE.md

@@ -75,7 +75,7 @@ Bearer/API Key 连接器会先执行 MCP `initialize` 验证。所有 Server 通
 
 stdio 市场卡片也可能显示一个或多个凭据字段，例如 API Token、区域或租户标识。卡片目录只声明字段名称及其环境变量映射；提交后，真实值仅保存到 DSH 本机连接记录，并由插件注入该 stdio 进程的 `env`。市场、状态页和日志不会返回这些值。插件会等待 Host 完成首次 MCP 初始化与工具同步后再保存连接；失败或超时不会增加已安装数量，卡片也不会提前显示“已连接”。
 
-OAuth 一键连接要求服务商支持标准 OAuth 2.1/PKCE 和公开元数据发现。动态客户端注册既支持无需客户端密钥的 `none`，也支持服务商签发密钥的 `client_secret_post` 与 `client_secret_basic`。客户端密钥仅与 OAuth Grant 一同保存在 DSH 本机，用于换取、刷新和撤销 Token；插件不会要求用户把 OAuth Token 或客户端密钥复制到聊天中。
+OAuth 一键连接要求服务商支持标准 OAuth 2.1/PKCE 和公开元数据发现。动态客户端注册既支持无需客户端密钥的 `none`，也支持服务商签发密钥的 `client_secret_post` 与 `client_secret_basic`。客户端密钥仅与 OAuth Grant 一同保存在 DSH 本机，用于换取、刷新和撤销 Token；插件不会要求用户把 OAuth Token 或客户端密钥复制到聊天中。如服务商在动态客户端注册阶段返回 HTTP 403，页面会明确提示“客户端注册被拒绝、尚未进入浏览器授权”；这通常需要服务商审核或登记客户端，重试用户授权无法绕过。
 
 当市场描述声明 `grantSharing: "issuer"` 时，同一账号下相同 issuer、scope 和客户端鉴权方式的卡片共享一组 Grant。首次授权仍只启用用户点击的卡片；之后连接同组卡片会直接复用现有授权，不再重复打开 OAuth 页面。升级时会验证并自动归并旧版本留下的同 issuer 多份 Grant；Desktop 与 `dsh web` 并发时，插件使用跨进程锁串行轮换，并从每 Grant 独立原子日志读取最新 Token，避免 DSH 整文件 storage 的旧进程快照覆盖新凭据。网络、OAuth 元数据发现或服务端 5xx 等暂时故障只进入“自动重试中”；确认 journal 中也没有更新 Token，且明确收到 Refresh Token/客户端失效错误时，才进入“需重新授权”。
 
@@ -120,11 +120,11 @@ OAuth 一键连接要求服务商支持标准 OAuth 2.1/PKCE 和公开元数据
 }
 ```
 
-导入前请把示例占位符替换为自己的值。凭据只应在本机导入，不要把含真实 Token、API Key、密码或 Cookie 的 JSON 提交到 Git、Issue 或聊天。
+导入前请把示例占位符替换为自己的值。凭据只应在本机导入，不要把含真实 Token、API Key、密码或 Cookie 的 JSON 提交到 Git、Issue 或聊天。导入私有 IP 的明文 HTTP 端点时，必须在对应 Server 条目中显式增加 `"allowInsecurePrivateNetwork": true`；该标记会跟随脱敏导出保留。
 
 ### 6.2 手动配置
 
-- **HTTP**：填写名称、HTTPS MCP URL、可选 Header 和传输方式。
+- **HTTP**：填写名称、HTTPS MCP URL、可选 Header 和传输方式。回环 HTTP 可直接使用；局域网私有 IP 明文 HTTP 需勾选风险确认。
 - **stdio**：填写本机命令、参数、环境变量和可选工作目录。
 
 stdio 进程由 `@deepseek-ai/dsh-mcp-client` 管理，插件透传 `command`、`args`、`env`、`cwd`，并等待 Host 完成首次 MCP 初始化和工具同步。stdio 会以当前用户权限启动本机进程，只运行你信任的软件包和命令。手动 HTTP 配置也会在保存前执行 `initialize` 校验；验证失败时表单内容仍保留，且不会生成无效连接记录。
@@ -220,7 +220,7 @@ OAuth 断开时，插件会尽力调用服务商的撤销端点；无撤销端
 - 凭据仅保存在 DSH storage domain，不进入市场目录、Git 仓库或对话历史。
 - stdio 目录只能声明凭据字段与 env 映射，不能给出真实值；Registry 探针不会执行目录中的本地命令。
 - OAuth 动态注册返回的 `client_secret` 不出现在目录、连接状态或日志中；断开连接时与 Refresh Token 一起尽力撤销并删除本机记录。
-- 外部 HTTP 地址必须使用 HTTPS；仅本机回环开发地址允许 HTTP。
+- 外部地址默认必须使用 HTTPS，本机回环地址允许 HTTP。用户自建连接只有在显式确认风险后，才允许 RFC1918 IPv4（`10/8`、`172.16/12`、`192.168/16`）或 RFC4193 IPv6 ULA 字面量使用明文 HTTP。域名、公网 HTTP、链路本地与云元数据地址仍拒绝；开启后凭据和工具数据可能被同网段监听或篡改。
 - Registry 健康探针不持有用户凭据，也绝不会执行目录里的 stdio 命令。
 - 连接器能看到的数据和能执行的操作取决于你授予的账户权限；优先使用最小权限 Token/API Key。
 - 生成、付费、写入、发布、删除、停止任务等有副作用的工具，应在执行前再次确认参数和影响。

package/lib/callback-server.js

@@ -73,12 +73,16 @@ export async function startCallbackServer({ path = '/callback', port = 0, host =
   const actualPort = server.address().port;
   const url = `http://${host}:${actualPort}${path}`;
 
-  const close = () =>
-    new Promise((resolve) => {
+  let closed = false;
+  const close = () => {
+    if (closed) return Promise.resolve();
+    closed = true;
+    return new Promise((resolve) => {
       clearTimeout(timer);
       if (signal) signal.removeEventListener('abort', onAbort);
       server.close(() => resolve());
     });
+  };
 
   const waitForCallback = async () => {
     try {

package/lib/connection-backup.js

@@ -77,6 +77,7 @@ function exportPortableConnection(record) {
   } else {
     const url = safeUrl(record.url);
     base.url = url.value;
+    if (record.allowInsecurePrivateNetwork === true) base.allowInsecurePrivateNetwork = true;
     if (url.redacted) redactedFields.push('url');
     if (Object.keys(record.headers ?? {}).length) {
       base.headers = redactedObjectValues(record.headers);

package/lib/connectors/json-connector.js

@@ -3,7 +3,7 @@
  * 批量预校验，支持 HTTP/SSE 与 stdio（command/args/env/cwd）。
  */
 import { JSON_CONNECTOR_ID } from '../constants.js';
-import { assertSafeUrl, assertSafeHeaderName, slugServerName } from '../util.js';
+import { assertConnectionUrl, assertSafeHeaderName, isPrivateNetworkHost, slugServerName } from '../util.js';
 import { unresolvedRedactions } from '../connection-backup.js';
 
 function parseInput(input) {
@@ -39,6 +39,17 @@ function normalizeTransport(value, hasCommand = false) {
   throw new Error(`unsupported transport: ${raw}`);
 }
 
+function normalizeHttpEndpoint(rawUrl, allowInsecurePrivateNetwork) {
+  const approved = allowInsecurePrivateNetwork === true;
+  const url = assertConnectionUrl(rawUrl, { allowInsecurePrivateNetwork: approved });
+  return {
+    url: url.toString(),
+    ...(approved && url.protocol === 'http:' && isPrivateNetworkHost(url.hostname)
+      ? { allowInsecurePrivateNetwork: true }
+      : {}),
+  };
+}
+
 function stdioRecord(name, cfg) {
   const command = String(cfg.command ?? '').trim();
   if (!command) return null;
@@ -129,13 +140,14 @@ export function normalizeJsonImport(input) {
         continue;
       }
       const { auth, headers } = extractAuth(cfg.headers ?? cfg.httpHeaders);
+      const endpoint = normalizeHttpEndpoint(cfg.url, cfg.allowInsecurePrivateNetwork);
       records.push({
         key: `json-${slugServerName(cfg.serverName ?? name)}`,
         connectorId: JSON_CONNECTOR_ID,
         kind: 'json',
         name: cfg.name ?? name,
         transport,
-        url: assertSafeUrl(cfg.url).toString(),
+        ...endpoint,
         serverName: slugServerName(cfg.serverName ?? name),
         headers,
         auth,
@@ -166,13 +178,14 @@ export function normalizeJsonImport(input) {
         skipped.push(`${name}(缺 url)`);
         continue;
       }
+      const endpoint = normalizeHttpEndpoint(item.url, item.allowInsecurePrivateNetwork);
       records.push({
         key: `json-${slugServerName(item.serverName ?? name)}`,
         connectorId: JSON_CONNECTOR_ID,
         kind: 'json',
         name,
         transport,
-        url: assertSafeUrl(item.url).toString(),
+        ...endpoint,
         serverName: slugServerName(item.serverName ?? name),
         headers: coerceHeaders(item.headers),
         auth: authFromFields(item),

package/lib/connectors/manual-connector.js

@@ -2,7 +2,7 @@
  * 通道二：自定义配置连接（表单式填 transport/url/serverName/鉴权）。
  */
 import { CUSTOM_CONNECTOR_ID } from '../constants.js';
-import { assertSafeUrl, assertSafeHeaderName, slugServerName } from '../util.js';
+import { assertConnectionUrl, assertSafeHeaderName, isPrivateNetworkHost, slugServerName } from '../util.js';
 
 function parseHeadersJson(headersJson) {
   if (headersJson === undefined || headersJson === null || headersJson === '') return {};
@@ -44,7 +44,7 @@ function parseEnvJson(envJson) {
 }
 
 /**
- * @param {object} params { name, url, transport?, serverName?, authMode?, bearerToken?, apiKeyHeader?, apiKeyValue?, headersJson? }
+ * @param {object} params { name, url, transport?, serverName?, authMode?, bearerToken?, apiKeyHeader?, apiKeyValue?, headersJson?, allowInsecurePrivateNetwork? }
  */
 export function buildManualRecord(params = {}) {
   const name = String(params.name ?? '').trim();
@@ -80,7 +80,13 @@ export function buildManualRecord(params = {}) {
     };
   }
 
-  const url = assertSafeUrl(params.url).toString();
+  const parsedUrl = assertConnectionUrl(params.url, {
+    allowInsecurePrivateNetwork: params.allowInsecurePrivateNetwork === true,
+  });
+  const url = parsedUrl.toString();
+  const allowInsecurePrivateNetwork = parsedUrl.protocol === 'http:'
+    && isPrivateNetworkHost(parsedUrl.hostname)
+    && params.allowInsecurePrivateNetwork === true;
   const headers = parseHeadersJson(params.headersJson);
 
   const authMode = params.authMode ?? 'none';
@@ -103,6 +109,7 @@ export function buildManualRecord(params = {}) {
     name,
     transport,
     url,
+    ...(allowInsecurePrivateNetwork ? { allowInsecurePrivateNetwork: true } : {}),
     serverName,
     headers,
     auth,

package/lib/connectors/oauth-connector.js

@@ -15,6 +15,71 @@ import {
 import { startCallbackServer } from '../callback-server.js';
 import { openBrowser } from '../util.js';
 
+const OAUTH_STAGE_LABELS = Object.freeze({
+  'resource-discovery': '受保护资源发现',
+  'server-metadata': 'OAuth 服务发现',
+  'callback-listener': '本机回调监听',
+  'client-registration': 'OAuth 客户端注册',
+  'authorization-callback': '浏览器授权回调',
+  'token-exchange': 'OAuth Token 换取',
+});
+
+async function atOAuthStage(stage, action) {
+  try {
+    return await action();
+  } catch (error) {
+    if (error && typeof error === 'object' && !error.oauthStage) {
+      error.oauthStage = stage;
+      error.oauthStageLabel = OAUTH_STAGE_LABELS[stage] ?? stage;
+    }
+    throw error;
+  }
+}
+
+function stagedError(stage, message) {
+  const error = new Error(message);
+  error.oauthStage = stage;
+  error.oauthStageLabel = OAUTH_STAGE_LABELS[stage] ?? stage;
+  return error;
+}
+
+/** 把 OAuth 底层异常收敛为可操作、不泄露响应体的用户诊断。 */
+export function describeOAuthAuthorizationError(error) {
+  const stage = error?.oauthStage ?? 'unknown';
+  const stageLabel = error?.oauthStageLabel ?? OAUTH_STAGE_LABELS[stage] ?? 'OAuth 授权';
+  const httpStatus = Number.isInteger(error?.httpStatus) ? error.httpStatus : undefined;
+  const upstreamCode = typeof error?.code === 'string' ? error.code : undefined;
+  if (stage === 'client-registration' && httpStatus === 403) {
+    return {
+      message: 'OAuth 客户端注册被服务商拒绝（HTTP 403），尚未进入浏览器授权。该服务可能只允许已审核客户端；请查看服务商的 MCP 客户端准入说明，或等待连接器完成官方登记。',
+      detail: {
+        kind: 'oauth-client-registration-rejected',
+        stage,
+        stageLabel,
+        code: 'oauth-dcr-forbidden',
+        httpStatus,
+        upstreamCode,
+      },
+    };
+  }
+  const safeReason = httpStatus
+    ? (upstreamCode && upstreamCode !== 'http_error' ? upstreamCode : '服务端拒绝请求')
+    : String(error?.message ?? '未知错误')
+      .replace(/[\r\n\t]+/g, ' ')
+      .replace(/\s{2,}/g, ' ')
+      .slice(0, 240);
+  return {
+    message: `${stageLabel}失败${httpStatus ? `（HTTP ${httpStatus}）` : ''}：${safeReason}`,
+    detail: {
+      kind: 'oauth-authorization',
+      stage,
+      stageLabel,
+      code: upstreamCode ?? 'oauth-error',
+      ...(httpStatus ? { httpStatus } : {}),
+    },
+  };
+}
+
 /**
  * @param {object} args
  * @param {object} args.connector 归一化后的连接器描述（auth.mode = oauth2-pkce）
@@ -24,88 +89,109 @@ import { openBrowser } from '../util.js';
  */
 export async function oauthAuthorize({ connector, config, logger, signal }) {
   const entryServer = connector.servers[0];
-  if (!entryServer) throw new Error(`connector "${connector.id}" has no servers`);
+  if (!entryServer) throw stagedError('resource-discovery', `connector "${connector.id}" has no servers`);
 
-  const protectedResource = await discoverProtectedResource(entryServer.url, config.requestTimeoutMs);
+  const protectedResource = await atOAuthStage(
+    'resource-discovery',
+    () => discoverProtectedResource(entryServer.url, config.requestTimeoutMs),
+  );
   const issuer = protectedResource.authorizationServers[0] ?? connector.auth.issuer;
-  if (!issuer) throw new Error(`connector "${connector.id}" missing issuer`);
+  if (!issuer) throw stagedError('resource-discovery', `connector "${connector.id}" missing issuer`);
 
-  const metadata = await discoverServerMetadata(issuer, config.requestTimeoutMs);
+  const metadata = await atOAuthStage(
+    'server-metadata',
+    () => 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}`);
+    throw stagedError('server-metadata', `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,
-  });
+  const callback = await atOAuthStage(
+    'callback-listener',
+    () => startCallbackServer({ path: '/callback', timeoutMs: config.callbackTimeoutMs, signal }),
+  );
+  try {
+    const registration = await atOAuthStage('client-registration', () => registerClient(metadata.registrationEndpoint, {
+      clientName: connector.auth.clientName,
+      redirectUris: [callback.url],
+      scope: connector.auth.scope,
+      tokenEndpointAuthMethod: requestedAuthMethod,
+      timeoutMs: config.requestTimeoutMs,
+    }));
 
-  const { verifier, challenge, method } = pkcePair();
-  const state = generateState();
-  const entryResource = protectedResource.resource ?? entryServer.url;
-  const authorizeUrl = buildAuthorizeUrl(metadata, {
-    clientId: registration.clientId,
-    redirectUri: callback.url,
-    state,
-    challenge,
-    challengeMethod: method,
-    resource: entryResource,
-    scope: connector.auth.scope,
-  });
+    const { verifier, challenge, method } = pkcePair();
+    const state = generateState();
+    const entryResource = protectedResource.resource ?? entryServer.url;
+    const authorizeUrl = buildAuthorizeUrl(metadata, {
+      clientId: registration.clientId,
+      redirectUri: callback.url,
+      state,
+      challenge,
+      challengeMethod: method,
+      resource: entryResource,
+      scope: connector.auth.scope,
+    });
 
-  logger.info(`opening authorization page: ${authorizeUrl}`);
-  if (config.openBrowser) openBrowser(authorizeUrl, logger);
-  else logger.info('openBrowser disabled — please open the URL above manually to authorize');
+    logger.info(`opening authorization page: ${authorizeUrl}`);
+    if (config.openBrowser) openBrowser(authorizeUrl, logger);
+    else logger.info('openBrowser disabled — please open the URL above manually to authorize');
 
-  const { code, state: returnedState } = await callback.waitForCallback();
-  if (returnedState !== state) throw new Error('OAuth callback state mismatch — aborting (possible CSRF)');
+    const { code, state: returnedState } = await atOAuthStage(
+      'authorization-callback',
+      () => callback.waitForCallback(),
+    );
+    if (returnedState !== state) {
+      const error = new Error('OAuth callback state mismatch — aborting (possible CSRF)');
+      error.oauthStage = 'authorization-callback';
+      error.oauthStageLabel = OAUTH_STAGE_LABELS['authorization-callback'];
+      throw error;
+    }
 
-  const token = await exchangeCode(metadata.tokenEndpoint, {
-    clientId: registration.clientId,
-    clientSecret: registration.clientSecret,
-    tokenEndpointAuthMethod: registration.tokenEndpointAuthMethod,
-    code,
-    redirectUri: callback.url,
-    codeVerifier: verifier,
-    resource: entryResource,
-    scope: connector.auth.scope,
-    timeoutMs: config.requestTimeoutMs,
-  });
+    const token = await atOAuthStage('token-exchange', () => exchangeCode(metadata.tokenEndpoint, {
+      clientId: registration.clientId,
+      clientSecret: registration.clientSecret,
+      tokenEndpointAuthMethod: registration.tokenEndpointAuthMethod,
+      code,
+      redirectUri: callback.url,
+      codeVerifier: verifier,
+      resource: entryResource,
+      scope: connector.auth.scope,
+      timeoutMs: config.requestTimeoutMs,
+    }));
 
-  // 按 token 实际授权范围过滤 server；非 JWT / 无 resource claim 时 fallback 全部
-  const grantedUrls = extractTokenResources(token.accessToken);
-  let grantedKeys;
-  let grantedResources;
-  if (grantedUrls) {
-    const granted = new Set(grantedUrls);
-    const grantedServers = connector.servers.filter((s) => granted.has(s.url));
-    grantedKeys = grantedServers.map((s) => s.serverKey);
-    grantedResources = grantedServers.map((s) => s.url);
-    if (grantedKeys.length === 0) {
-      grantedKeys = [entryServer.serverKey];
-      grantedResources = [entryServer.url];
+    // 按 token 实际授权范围过滤 server；非 JWT / 无 resource claim 时 fallback 全部
+    const grantedUrls = extractTokenResources(token.accessToken);
+    let grantedKeys;
+    let grantedResources;
+    if (grantedUrls) {
+      const granted = new Set(grantedUrls);
+      const grantedServers = connector.servers.filter((s) => granted.has(s.url));
+      grantedKeys = grantedServers.map((s) => s.serverKey);
+      grantedResources = grantedServers.map((s) => s.url);
+      if (grantedKeys.length === 0) {
+        grantedKeys = [entryServer.serverKey];
+        grantedResources = [entryServer.url];
+      }
+    } else {
+      grantedKeys = connector.servers.map((s) => s.serverKey);
+      grantedResources = connector.servers.map((s) => s.url);
     }
-  } else {
-    grantedKeys = connector.servers.map((s) => s.serverKey);
-    grantedResources = connector.servers.map((s) => s.url);
-  }
 
-  return {
-    issuer,
-    clientId: registration.clientId,
-    clientSecret: registration.clientSecret,
-    clientSecretExpiresAt: registration.clientSecretExpiresAt,
-    tokenEndpointAuthMethod: registration.tokenEndpointAuthMethod,
-    clientName: connector.auth.clientName,
-    scope: connector.auth.scope,
-    token,
-    grantedKeys,
-    grantedResources,
-    entryResource,
-  };
+    return {
+      issuer,
+      clientId: registration.clientId,
+      clientSecret: registration.clientSecret,
+      clientSecretExpiresAt: registration.clientSecretExpiresAt,
+      tokenEndpointAuthMethod: registration.tokenEndpointAuthMethod,
+      clientName: connector.auth.clientName,
+      scope: connector.auth.scope,
+      token,
+      grantedKeys,
+      grantedResources,
+      entryResource,
+    };
+  } finally {
+    await callback.close().catch((error) => logger?.warn(`close OAuth callback listener failed: ${error.message}`));
+  }
 }

package/lib/index.js

@@ -26,7 +26,7 @@ import {
 import { defineConnectorDomain, ConnectionStore, GrantStore, CatalogStore, SnapshotStore, GovernanceStore, ConnectionScopeStore } from './stores.js';
 import { normalizeConnectorDescriptor, normalizeConnectionRecord } from './schema.js';
 import { loadBundledCatalog, fetchRemoteCatalogWithFallback, mergeCatalog, listCatalog, auditDescriptor, auditRawDescriptor, readLimitedJson } from './catalog.js';
-import { oauthAuthorize } from './connectors/oauth-connector.js';
+import { describeOAuthAuthorizationError, oauthAuthorize } from './connectors/oauth-connector.js';
 import { buildManualRecord } from './connectors/manual-connector.js';
 import { normalizeJsonImport } from './connectors/json-connector.js';
 import { discoverServerMetadata, refreshAccessToken, revokeRefreshToken, extractTokenResources } from './oauth.js';
@@ -1876,11 +1876,12 @@ export async function apply(ctx, config) {
               detail: { keys: created, grantKey, sharedGrant: sharingConnectors.length > 1, retiredGrantCount, snapshotId: snapshot?.key ?? null, scopeRevision, scopeRollbackRevision },
             };
           } catch (error) {
-            logger.error(`oauth connect failed: ${error.message}`);
+            const failure = describeOAuthAuthorizationError(error);
+            logger.error(`oauth connect failed [${failure.detail.stage}/${failure.detail.code}]: ${failure.message}`);
             await pruneOrphanGrants();
             return error?.connectionRecord
               ? connectionSetupFailure(error)
-              : { ok: false, message: `连接失败: ${error.message}` };
+              : { ok: false, message: `连接失败: ${failure.message}`, detail: failure.detail };
           }
         })();
         state.oauthConnects.set(sharingKey, { promise, requestedConnectorIds });
@@ -2182,6 +2183,7 @@ export async function apply(ctx, config) {
           url: record.url,
           transport: record.transport,
           endpoint: record.transport === 'stdio' ? `stdio · ${record.command}` : record.url,
+          insecurePrivateNetwork: record.allowInsecurePrivateNetwork === true,
           enabled: record.enabled !== false,
           authMode: record.auth?.mode ?? 'none',
           grant: grantInfo,

package/lib/schema.js

@@ -3,6 +3,7 @@
  * 使用 zod v4；字段默认值在 normalize 阶段补齐，schema 只做形状校验（宽松校验、显式报错）。
  */
 import { z } from 'zod';
+import { assertConnectionUrl, isPrivateNetworkHost } from './util.js';
 
 /** 连接器目录里单个 MCP server 的描述 */
 export const serverRefSchema = z.object({
@@ -105,6 +106,7 @@ export const connectionRecordSchema = z.object({
   serverKey: z.string().min(1).optional(),
   transport: z.enum(['streamable-http', 'sse', 'stdio']),
   url: z.string().min(1).optional(),
+  allowInsecurePrivateNetwork: z.boolean().optional(),
   command: z.string().min(1).optional(),
   args: z.array(z.string()).optional(),
   env: z.record(z.string()).optional(),
@@ -318,10 +320,17 @@ export function normalizeConnectionRecord(raw) {
   if (transport === 'streamable-http' && !data.url) {
     throw new Error('invalid connection record: transport=streamable-http 时 url 必填');
   }
+  const parsedUrl = transport === 'streamable-http'
+    ? assertConnectionUrl(data.url, { allowInsecurePrivateNetwork: data.allowInsecurePrivateNetwork === true })
+    : null;
+  const allowInsecurePrivateNetwork = parsedUrl?.protocol === 'http:'
+    && isPrivateNetworkHost(parsedUrl.hostname)
+    && data.allowInsecurePrivateNetwork === true;
   return {
     ...data,
     transport,
-    url: transport === 'streamable-http' ? data.url : undefined,
+    url: parsedUrl?.toString(),
+    allowInsecurePrivateNetwork: allowInsecurePrivateNetwork || undefined,
     command: transport === 'stdio' ? data.command : undefined,
     args: transport === 'stdio' ? (data.args ?? []) : undefined,
     env: transport === 'stdio' ? (data.env ?? {}) : undefined,

package/lib/tools.js

@@ -215,7 +215,11 @@ export function registerTools(ctx, api) {
       properties: {
         connectorId: { type: 'string', description: '市场凭据型连接器 id；提供时无需 name/url' },
         name: { type: 'string', description: '连接展示名' },
-        url: { type: 'string', description: 'MCP 端点 URL（https 或回环 http）' },
+        url: { type: 'string', description: 'MCP 端点 URL（https 或回环 http；私有 IP 的 http 需显式授权）' },
+        allowInsecurePrivateNetwork: {
+          type: 'boolean',
+          description: '仅用于用户自建连接：显式授权 RFC1918 IPv4 / RFC4193 IPv6 ULA 字面量使用明文 HTTP；公网 HTTP 与域名仍拒绝',
+        },
         transport: { type: 'string', enum: ['streamable-http', 'stdio', 'sse'], description: '传输方式；sse 会兼容归一为 streamable-http' },
         command: { type: 'string', description: 'transport=stdio 时的启动命令（如 npx、uvx）' },
         args: { type: 'array', items: { type: 'string' }, description: 'transport=stdio 时的参数列表' },
@@ -248,7 +252,8 @@ export function registerTools(ctx, api) {
     name: 'mcp_connector_import_json',
     description:
       '粘贴 JSON 批量导入外部 MCP 连接。支持 HTTP/SSE 与 stdio（command/args/env/cwd）：{ "mcpServers": { "name": {...} } } ' +
-      '或 { "connections": [ {...} ] }。整体预校验，任一非法整体拒绝。',
+      '或 { "connections": [ {...} ] }。局域网明文 HTTP 需在对应条目显式填写 allowInsecurePrivateNetwork=true。' +
+      '整体预校验，任一非法整体拒绝。',
     parameters: {
       type: 'object',
       properties: {

package/lib/util.js

@@ -3,6 +3,7 @@
  */
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
+import { isIP } from 'node:net';
 
 /**
  * 按平台构建打开命令（纯函数，便于单测）。
@@ -51,19 +52,65 @@ export function slugServerName(input) {
   return slug;
 }
 
-/** URL 协议白名单：仅 https / 回环 http */
-export function assertSafeUrl(rawUrl) {
+function parseUrl(rawUrl) {
   let url;
   try {
     url = new URL(rawUrl);
   } catch {
     throw new Error(`invalid url: ${rawUrl}`);
   }
+  return url;
+}
+
+function normalizedHostname(hostname) {
+  return String(hostname ?? '').trim().toLowerCase().replace(/^\[|\]$/g, '');
+}
+
+/** 只接受字面量 RFC1918 IPv4 或 RFC4193 IPv6 ULA，不解析域名，避免 DNS rebinding。 */
+export function isPrivateNetworkHost(hostname) {
+  const host = normalizedHostname(hostname);
+  const version = isIP(host);
+  if (version === 4) {
+    const octets = host.split('.').map(Number);
+    return octets[0] === 10
+      || (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31)
+      || (octets[0] === 192 && octets[1] === 168);
+  }
+  if (version === 6) {
+    const firstHextet = Number.parseInt(host.split(':', 1)[0], 16);
+    return Number.isFinite(firstHextet) && (firstHextet & 0xfe00) === 0xfc00;
+  }
+  return false;
+}
+
+function isLoopbackHost(hostname) {
+  return ['127.0.0.1', 'localhost', '::1'].includes(normalizedHostname(hostname));
+}
+
+/** URL 协议白名单：仅 https / 回环 http。用于目录、OAuth 和其他公共边界。 */
+export function assertSafeUrl(rawUrl) {
+  const url = parseUrl(rawUrl);
   if (url.protocol === 'https:') return url;
-  if (url.protocol === 'http:' && ['127.0.0.1', 'localhost', '::1'].includes(url.hostname)) return url;
+  if (url.protocol === 'http:' && isLoopbackHost(url.hostname)) return url;
   throw new Error(`url protocol not allowed (only https or loopback http): ${rawUrl}`);
 }
 
+/**
+ * 用户自建 MCP 连接的窄范围例外：默认仍拒绝局域网 HTTP，只在用户显式确认且
+ * host 为私有 IP 字面量时放行。公网 HTTP、域名、链路本地和元数据地址仍拒绝。
+ */
+export function assertConnectionUrl(rawUrl, { allowInsecurePrivateNetwork = false } = {}) {
+  const url = parseUrl(rawUrl);
+  if (url.protocol === 'https:' || (url.protocol === 'http:' && isLoopbackHost(url.hostname))) return url;
+  if (url.protocol === 'http:' && isPrivateNetworkHost(url.hostname)) {
+    if (allowInsecurePrivateNetwork === true) return url;
+    const error = new Error(`insecure private-network HTTP requires explicit confirmation: ${rawUrl}`);
+    error.code = 'INSECURE_PRIVATE_NETWORK_REQUIRES_CONFIRMATION';
+    throw error;
+  }
+  throw new Error(`url protocol not allowed (only https, loopback http, or explicitly approved private-network http): ${rawUrl}`);
+}
+
 /** header 名白名单 */
 export function assertSafeHeaderName(name) {
   if (!/^[A-Za-z0-9_-]+$/.test(String(name))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mcp-connector",
-  "version": "0.2.33",
+  "version": "0.2.35",
   "description": "DeepSeek Harness MCP Connector and MCP Server marketplace with over one hundred MCP connectors, continuously updated. Discover, authorize, and manage connections in one place; supports OAuth 2.0 PKCE, API keys, stdio/HTTP, mcpServers JSON import, and tool and prompt discovery. Maintained by Qichacha/QCC.",
   "type": "module",
   "main": "lib/index.js",

package/ui/index.html

@@ -386,6 +386,8 @@
   .field-help a:hover { text-decoration: underline; }
   .form-note { color: var(--text-2); background: var(--accent-light); border: 1px solid var(--line); border-radius: 8px; padding: 10px 12px; margin: 12px 0; font-size: 11px; line-height: 1.55; }
   .form-note strong { display: block; color: var(--text); font-size: 12px; margin-bottom: 2px; }
+  .modal .insecure-network-consent { display: flex; align-items: flex-start; gap: 8px; color: var(--warn); line-height: 1.45; }
+  .modal .insecure-network-consent input { width: auto; margin: 2px 0 0; padding: 0; flex: 0 0 auto; }
   .server-preview { max-height: 132px; overflow-y: auto; border: 1px solid var(--line); border-radius: 8px; margin-top: 10px; }
   .server-preview div { padding: 7px 10px; border-top: 1px solid var(--line); color: var(--text-2); font: 11px/1.4 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; overflow-wrap: anywhere; }
   .server-preview div:first-child { border-top: 0; }
@@ -694,6 +696,18 @@
     setDetailOpen(false);
   }
 
+  function isDetailOpenFor(connectorId) {
+    return detailConnector?.id === connectorId && $('#detail-overlay').classList.contains('active');
+  }
+
+  async function refreshConnectionUi(connectorId) {
+    const reloadOpenDetail = isDetailOpenFor(connectorId);
+    const openDetailLoadId = detailLoadId;
+    await refresh();
+    if (!reloadOpenDetail || detailLoadId !== openDetailLoadId || !isDetailOpenFor(connectorId)) return;
+    await window.__mcp.showDetail(connectorId);
+  }
+
   function promptVariableNames(text) {
     const names = [];
     const seen = new Set();
@@ -1091,13 +1105,14 @@
     const healthClass = r.connectionState === 'healthy' ? 'pass' : ['reauth', 'recovering', 'degraded'].includes(r.connectionState) ? 'partial' : r.connectionState === 'unavailable' ? 'fail' : '';
     const healthBadge = `<span class="badge ${healthClass}">${esc(healthLabels[r.connectionState] || '状态未知')}</span>`;
     const scopeBadge = `<span class="badge">${esc(r.scope?.label || '全局')}</span>`;
+    const insecureNetworkBadge = r.insecurePrivateNetwork === true ? '<span class="badge partial">局域网 HTTP 风险已确认</span>' : '';
     const enabled = r.enabled !== false;
     const diagnostic = r.diagnostic
       ? `<div class="rdiag">${esc(r.diagnostic.stageLabel || r.diagnostic.stage)} · ${esc(r.diagnostic.code)}：${esc(r.diagnostic.message)}；建议：${esc(r.diagnostic.action)}${r.lastSuccessfulAt ? `；最近成功：${esc(new Date(r.lastSuccessfulAt).toLocaleString('zh-CN', { hour12: false }))}` : ''}</div>`
       : '';
     return `<div class="row" data-key="${key}">
       <div class="info">
-        <div class="rname">${esc(r.name)} ${authMode} ${healthBadge} ${scopeBadge}</div>
+        <div class="rname">${esc(r.name)} ${authMode} ${healthBadge} ${scopeBadge} ${insecureNetworkBadge}</div>
         <div class="rmeta">${esc(r.serverName || '')} · ${esc(r.endpoint || r.url || '')}</div>
         ${diagnostic}
       </div>
@@ -1113,7 +1128,8 @@
   function guidanceFor(message) {
     const text = String(message || '未知错误');
     const withAdvice = (advice) => `${text.replace(/[。！？.!?\s]+$/, '')}。${advice}`;
-    if (/protocol not allowed|only https/i.test(text)) return withAdvice('公网地址必须使用 HTTPS；HTTP 只允许 localhost/127.0.0.1。');
+    if (/private-network HTTP requires explicit confirmation/i.test(text)) return withAdvice('如目标是可信的局域网私有 IP，请勾选明文 HTTP 风险确认；请勿对公网或不可信服务开启。');
+    if (/protocol not allowed|only https/i.test(text)) return withAdvice('公网地址必须使用 HTTPS；HTTP 只允许回环地址，或经显式确认的私有 IP 字面量。');
     if (/JSON/i.test(text)) return withAdvice('请检查引号、逗号，并确认顶层是 mcpServers 或 connections。');
     if (/401|403|token|凭据|api.?key/i.test(text)) return withAdvice('请核对鉴权方式、Token/API Key 是否有效以及 Header 名。');
     if (/timeout|timed out|fetch|连接|network/i.test(text)) return withAdvice('请检查网络、端点是否可达以及 MCP URL 是否完整。');
@@ -1224,7 +1240,7 @@
       openModal('添加 MCP 连接', `${addTabs(mode)}
         <div class="field-label-row"><label for="import-json">粘贴 MCP JSON</label><button class="text-btn" type="button" onclick="window.__mcp.formatImportJson(false)">格式化 JSON</button></div>
         <textarea id="import-json" rows="8" spellcheck="false" placeholder="${esc(MCP_JSON_EXAMPLE)}" onpaste="setTimeout(() => window.__mcp.formatImportJson(true), 0)"></textarea>
-        <div class="field-help">支持 <code>mcpServers</code> 的 Streamable HTTP、SSE 与 stdio（command/args/env/cwd），配置和凭据仅保存在 DSH 本机。</div>
+        <div class="field-help">支持 <code>mcpServers</code> 的 Streamable HTTP、SSE 与 stdio（command/args/env/cwd），配置和凭据仅保存在 DSH 本机。私有 IP 明文 HTTP 必须在对应条目显式设置 <code>"allowInsecurePrivateNetwork": true</code>。</div>
         ${scopeFieldHtml()}
         <div class="inline-error" id="modal-error" tabindex="-1"></div>
         <div class="m-actions"><button class="btn ghost" type="button" onclick="window.__mcp.closeModal()">取消</button><button class="btn" type="button" onclick="window.__mcp.submitImport()">校验并导入</button></div>`);
@@ -1250,6 +1266,8 @@
       <label for="cfg-transport">传输方式</label><select id="cfg-transport" onchange="window.__mcp.syncTransportFields()"><option value="streamable-http">Streamable HTTP（兼容 SSE）</option><option value="stdio">stdio（本地进程）</option></select>
       <div id="cfg-http-fields">
         <label for="cfg-url">MCP URL（必填）</label><input id="cfg-url" type="url" value="${esc(server.url || '')}" placeholder="https://example.com/mcp" />
+        <label class="insecure-network-consent" for="cfg-allow-insecure-lan"><input id="cfg-allow-insecure-lan" type="checkbox" />我确认这是可信的局域网私有 IP，并接受 HTTP 传输可被同网段监听或篡改的风险。</label>
+        <div class="field-help">仅放行 10/8、172.16/12、192.168/16 和 IPv6 ULA 字面量；域名、公网 HTTP、链路本地与云元数据地址仍会被拒绝。</div>
         <label for="cfg-auth">鉴权方式</label><select id="cfg-auth" onchange="window.__mcp.syncAuthFields()"><option value="none" ${suggestedAuth === 'none' ? 'selected' : ''}>无鉴权</option><option value="bearer" ${suggestedAuth === 'bearer' ? 'selected' : ''}>Bearer Token</option><option value="api-key" ${suggestedAuth === 'api-key' ? 'selected' : ''}>API Key</option></select>
         <div id="cfg-bearer"><label for="cfg-token">Bearer Token（必填）</label><input id="cfg-token" type="password" autocomplete="off" placeholder="仅保存在本机" /></div>
         <div id="cfg-apikey" class="form-row"><div><label for="cfg-key-header">API Key Header</label><input id="cfg-key-header" value="${esc(preset.authMode === 'api-key' ? 'X-Api-Key' : '')}" placeholder="X-Api-Key" /></div><div><label for="cfg-key-value">API Key（必填）</label><input id="cfg-key-value" type="password" autocomplete="off" placeholder="仅保存在本机" /></div></div>
@@ -1331,7 +1349,7 @@
         markCommunityCtaEligible();
         closeModal();
         await call('healthCheck', { connectorId });
-        await refresh();
+        await refreshConnectionUi(connectorId);
       }
     },
     confirmConnect() {
@@ -1478,11 +1496,9 @@
         });
         setModalBusy(false);
         if (!r.ok) { showModalError(r.message); return; }
-        const configuredFromDetail = detailConnector?.id === connectorId && $('#detail-overlay').classList.contains('active');
         closeModal();
-        if (configuredFromDetail) closeDetail();
         markCommunityCtaEligible();
-        showToast(r.message, true); await refresh();
+        showToast(r.message, true); await refreshConnectionUi(connectorId);
         return;
       }
       const name = $('#cfg-name').value.trim();
@@ -1509,6 +1525,7 @@
         name, url: url || undefined, serverName, headersJson,
         transport, command: command || undefined, args, envJson, cwd: $('#cfg-cwd')?.value.trim() || undefined,
         authMode: transport === 'stdio' ? 'none' : authMode,
+        allowInsecurePrivateNetwork: transport !== 'stdio' && $('#cfg-allow-insecure-lan')?.checked === true,
         bearerToken: $('#cfg-token')?.value || undefined,
         apiKeyHeader: $('#cfg-key-header')?.value || undefined,
         apiKeyValue: $('#cfg-key-value')?.value || undefined,
@@ -1742,8 +1759,7 @@
         if (r.ok) {
           markCommunityCtaEligible();
           await call('healthCheck', { connectorId: id });
-          closeDetail();
-          await refresh();
+          await refreshConnectionUi(id);
         }
         return;
       }