dsh-mcp-connector 0.2.39 → 0.2.41

package/CHANGELOG.md

@@ -4,6 +4,37 @@
 
 ## [Unreleased]
 
+## [0.2.41] - 2026-09-09
+
+### Added
+
+- “已安装”页为用户自定义和 JSON 导入的连接新增“编辑配置”，可修改标准化单连接 JSON 并保存后重新连接，无需先断开和删除。
+- 新增 `mcp_connector_get_editable_config` 与 `mcp_connector_reconfigure` 对话工具，提供相同的安全编辑和原子更新能力。
+
+### Changed
+
+- 已有 Token/API Key、Header/env 值、stdio 参数、本地路径及可能含凭据的 URL 只以 `<KEEP_EXISTING>` 返回；提交时在本机 storage-domain 内合并，也可显式替换或删除，不会将真实值发送到页面或对话。
+- 配置更新锁定 connection key 与 `serverName`，保留原连接范围和启停状态；更新前完成连接校验并创建快照，校验、Host 启动或持久化失败时原连接保持可用。
+
+### Verification
+
+- 216 项自动测试、lint、版本/营销元数据/商店截图门禁和 npm 发布包白名单/敏感内容扫描全部通过；新增覆盖敏感值保留/替换/清除、HTTP/stdio、连接身份约束、Web API、对话工具、停用状态、失败保留与快照。
+
+## [0.2.40] - 2026-09-09
+
+### Added
+
+- “已安装”页为用户自定义和 JSON 导入的 MCP 连接新增“重命名”，启用状态下也可无中断修改显示名。
+- 新增 `mcp_connector_rename` 对话工具，便于按连接 key 修改显示名。
+
+### Changed
+
+- 重命名只更新本机连接元数据并创建可恢复快照；connection key、`serverName`、工具前缀、连接范围、凭据和 Host 挂载均保持不变。
+
+### Verification
+
+- 209 项自动测试、lint、版本/营销元数据/商店截图门禁和 npm 发布包白名单/敏感内容扫描全部通过；新增覆盖显示名校验、Web API、对话工具、界面入口、启用状态下无重挂载、脱敏导出、快照与重启持久化。
+
 ## [0.2.39] - 2026-09-08
 
 ### Fixed
@@ -607,7 +638,9 @@
 - 外部 URL 与导入 Header 执行安全校验。
 - iframe 消息校验同源和消息来源。
 
-[Unreleased]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.39...HEAD
+[Unreleased]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.41...HEAD
+[0.2.41]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.40...v0.2.41
+[0.2.40]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.39...v0.2.40
 [0.2.39]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.38...v0.2.39
 [0.2.38]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.37...v0.2.38
 [0.2.37]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.36...v0.2.37

package/README.en.md

@@ -57,6 +57,7 @@ If the plugin helps you connect an MCP server faster, consider [starring the rep
 - 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, retry transient OAuth refresh failures with bounded backoff, and revoke authorization. Cards declaring issuer-level sharing reuse one grant; a cross-process lock and per-grant atomic journal prevent Desktop and Web hosts from consuming or overwriting the same rotating refresh token.
+- In-place configuration editing for custom and JSON-imported connections: edit normalized JSON from Installed and reconnect without deleting the connection. Existing sensitive values use local keep markers, and validation, startup, or persistence failures leave the previous connection usable.
 - Portable redacted configuration export plus up to 20 local pre-change snapshots, with preview and atomic restore. Credentials, local paths, and OAuth grants never enter the export.
 - Project/global connection scopes: choose the current DSH Workspace or profile-global visibility when connecting, preview affected servers/tools, then copy, move, or roll back by revision. Credentials remain single-copy and project-only tools are enforced by the DSH Host.
 - Three-layer Connection, Server, and Tool governance with Tool > Server > Connection > default-allow precedence, preview, revision-checked commits, and rollback. DSH Host restrictions narrow schemas/lookups/dispatch while a final execution guard prevents UI-only enforcement.
@@ -175,7 +176,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.39`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.39](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.39).
+The current public version is [`dsh-mcp-connector@0.2.41`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.41](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.41).
 
 See [CHANGELOG.md](CHANGELOG.md) for version history and [docs/DESKTOP-E2E.md](docs/DESKTOP-E2E.md) for the Desktop release checklist.
 

package/README.md

@@ -57,6 +57,7 @@ dsh plugin --profile web add dsh-mcp-connector
 - 三种接入：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 自动刷新/退避恢复与撤销；同 issuer 卡片共享一次授权，跨进程锁与独立原子 Grant journal 防止 Desktop/Web 并行时重复消耗 Refresh Token。
+- 配置原地编辑：自定义和 JSON 导入连接可在“已安装”中编辑标准化 JSON 并重新连接；敏感值以本机保留标记处理，校验、启动或保存失败时原连接继续可用。
 - 配置备份：一键复制/下载可再次导入的脱敏 JSON；连接变更前自动保存最多 20 个本机快照，支持预览与原子恢复。凭据、本地路径和 OAuth Grant 不进入导出结果。
 - 连接作用域：新连接可选当前 Workspace 项目或 profile 全局；支持先预览 Server/工具影响，再复制、移动或按 revision 回滚。凭据只存一份，project-only 工具由 DSH Host 强制隔离。
 - 三层治理：Connection、Server、Tool 规则按 Tool > Server > Connection > 默认允许解析；变更先预览、按 revision 提交并可回滚，由 DSH Host 的 schema/lookup/dispatch restriction 与最终执行 Guard 真实生效。
@@ -171,7 +172,7 @@ npm run dev:ui
 
 公共 Registry 每次合并后会生成 `catalog-stats.json`；本仓库的定时工作流每小时同步中英文介绍和统计快照。npm 页面中的静态正文随版本发布更新，上方动态统计徽标则直接读取 Registry，可在不发布新 npm 版本时保持实时数量一致。
 
-当前公开版本为 [`dsh-mcp-connector@0.2.39`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.39](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.39)。
+当前公开版本为 [`dsh-mcp-connector@0.2.41`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.41](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.41)。
 
 版本能力与变更记录见 [CHANGELOG.md](CHANGELOG.md)。
 Desktop 发版回归见 [docs/DESKTOP-E2E.md](docs/DESKTOP-E2E.md)。

package/docs/USER-GUIDE.md

@@ -152,6 +152,8 @@ stdio 进程由 `@deepseek-ai/dsh-mcp-client` 管理，插件透传 `command`、
 在“已安装”中可以：
 
 - 查看连接状态和 Server 数量；
+- 编辑自定义或 JSON 导入连接的标准化 JSON，并保存后重新连接；
+- 修改自定义或 JSON 导入连接的显示名，无需先停用连接；
 - 启用或停用连接；
 - 重新授权 OAuth，或重新录入 Token/API Key；
 - 执行健康检查；
@@ -159,12 +161,18 @@ stdio 进程由 `@deepseek-ai/dsh-mcp-client` 管理，插件透传 `command`、
 
 OAuth 断开时，插件会尽力调用服务商的撤销端点；无撤销端点时仍会删除 DSH 本机授权记录。连接状态发生变化后，可点击“刷新连接器目录”重新检查。
 
+“重命名”只修改用户看到的连接显示名，不会改变 connection key、`serverName`、`mcp__<serverName>__*` 工具前缀、连接范围、凭据或启停状态，也不会重新挂载 MCP Server。市场连接器的名称继续由公共目录维护。
+
+“编辑配置”会展示一条标准化的 `connections` JSON，不保证恢复最初导入文本的排版、注释或字段别名。`serverName` 与 connection key 共同标识现有连接，因此不能在此修改；如需新的工具前缀，请另建连接。Token/API Key、Header/env 值、stdio 参数、本地目录以及可能含凭据的 URL 不会返回页面，而是显示 `<KEEP_EXISTING>`：保留标记表示继续使用本机原值，替换标记可录入新值，删除对应字段可清除该项。
+
+启用中的连接点击“保存并重连”后会先验证新配置、创建快照，再原子更新 Host 与本机记录；任何校验、启动或持久化失败都会保留原连接。停用连接可以保存配置但仍保持停用。连接范围和启停状态均不会被 JSON 静默改变。市场/OAuth 连接继续使用卡片的“配置”或“重新授权”流程。
+
 ### 7.1 配置备份与恢复
 
 “已安装”页的“配置备份”提供两种互补能力：
 
 - **脱敏导出**：复制或下载可携带 JSON。Token/API Key、静态 Header/env 值、stdio 参数、本地目录以及可能含凭据的 URL 会变成明确占位符；目标设备导入前必须重填。OAuth 只导出连接引用，必须从市场重新授权。
-- **本机快照**：连接、配置、导入、启停或断开前自动保存变更范围，也可手动创建；最多保留 20 个。恢复前可查看将恢复和移除的 key，恢复过程中任一 Server 或持久化步骤失败会整体回到恢复前状态。
+- **本机快照**：连接、配置、导入、重命名、启停或断开前自动保存变更范围，也可手动创建；最多保留 20 个。恢复前可查看将恢复和移除的 key，恢复过程中任一 Server 或持久化步骤失败会整体回到恢复前状态。
 
 快照可能包含用于原样恢复的本机凭据，因此只保存在当前 profile 的 storage domain，不会通过 Web API、对话工具或日志原样返回。断开并撤销 OAuth 后，快照不能重建服务端 Grant，会明确要求重新授权。完整边界见[配置备份说明](CONFIG-BACKUP.md)。
 

package/lib/connection-editor.js

@@ -0,0 +1,216 @@
+/**
+ * 用户自定义 / JSON 连接的安全编辑视图。
+ *
+ * 浏览器只拿到标准化 JSON 与“保留现有值”标记，已有 Token、Header/env 值、
+ * stdio 参数和本地路径始终留在 storage-domain 内。提交时再在本机合并这些值。
+ */
+import { CUSTOM_CONNECTOR_ID, JSON_CONNECTOR_ID } from './constants.js';
+import { normalizeJsonImport } from './connectors/json-connector.js';
+import { normalizeConnectionDisplayName } from './util.js';
+
+export const KEEP_EXISTING_VALUE = '<KEEP_EXISTING>';
+
+export function connectionConfigurationEditable(record) {
+  return [CUSTOM_CONNECTOR_ID, JSON_CONNECTOR_ID].includes(record?.connectorId)
+    && record?.auth?.mode !== 'oauth';
+}
+
+function keepObjectKeys(input, path, preservedFields) {
+  const output = {};
+  for (const key of Object.keys(input ?? {}).sort()) {
+    output[key] = KEEP_EXISTING_VALUE;
+    preservedFields.push(`${path}.${key}`);
+  }
+  return output;
+}
+
+function safeUrl(record, preservedFields) {
+  try {
+    const url = new URL(record.url);
+    if (!url.username && !url.password && !url.search && !url.hash) return url.toString();
+  } catch {}
+  preservedFields.push('connections[0].url');
+  return KEEP_EXISTING_VALUE;
+}
+
+function safeCommand(record, preservedFields) {
+  const command = String(record.command ?? '');
+  if (/^[A-Za-z0-9_.@+-]+$/.test(command)) return command;
+  preservedFields.push('connections[0].command');
+  return KEEP_EXISTING_VALUE;
+}
+
+/** 返回单连接、标准化的可编辑 JSON；不返回任何已有敏感值。 */
+export function editableConnectionConfiguration(record) {
+  if (!connectionConfigurationEditable(record)) {
+    throw new Error('仅用户自定义或 JSON 导入的连接可编辑配置；市场连接器请使用配置或重新授权入口');
+  }
+  const preservedFields = [];
+  const item = {
+    name: record.name,
+    serverName: record.serverName,
+    transport: record.transport === 'stdio' ? 'stdio' : 'streamable-http',
+  };
+
+  if (record.transport === 'stdio') {
+    item.command = safeCommand(record, preservedFields);
+    if ((record.args ?? []).length > 0) {
+      item.args = [KEEP_EXISTING_VALUE];
+      preservedFields.push('connections[0].args');
+    } else item.args = [];
+    item.env = keepObjectKeys(record.env, 'connections[0].env', preservedFields);
+    if (record.cwd) {
+      item.cwd = KEEP_EXISTING_VALUE;
+      preservedFields.push('connections[0].cwd');
+    } else item.cwd = '';
+  } else {
+    item.url = safeUrl(record, preservedFields);
+    if (record.allowInsecurePrivateNetwork === true) item.allowInsecurePrivateNetwork = true;
+    item.headers = keepObjectKeys(record.headers, 'connections[0].headers', preservedFields);
+    item.authMode = record.auth?.mode ?? 'none';
+    if (record.auth?.mode === 'bearer') {
+      item.bearerToken = KEEP_EXISTING_VALUE;
+      preservedFields.push('connections[0].bearerToken');
+    } else if (record.auth?.mode === 'api-key') {
+      item.apiKeyHeader = record.auth.apiKeyHeader || 'X-Api-Key';
+      item.apiKeyValue = KEEP_EXISTING_VALUE;
+      preservedFields.push('connections[0].apiKeyValue');
+    }
+  }
+
+  return {
+    key: record.key,
+    serverName: record.serverName,
+    normalized: true,
+    preservedFields,
+    json: JSON.stringify({ connections: [item] }, null, 2),
+  };
+}
+
+function parseInput(input) {
+  if (typeof input !== 'string') return structuredClone(input);
+  try {
+    return JSON.parse(input);
+  } catch (error) {
+    throw new Error(`JSON 解析失败: ${error.message}`);
+  }
+}
+
+function singleConfig(document) {
+  if (!document || typeof document !== 'object' || Array.isArray(document)) {
+    throw new Error('JSON 顶层必须是对象');
+  }
+  if (Array.isArray(document.connections)) {
+    if (document.connections.length !== 1) throw new Error('编辑配置时只能提交当前这一条 connection');
+    return document.connections[0];
+  }
+  if (document.mcpServers && typeof document.mcpServers === 'object' && !Array.isArray(document.mcpServers)) {
+    const entries = Object.entries(document.mcpServers);
+    if (entries.length !== 1) throw new Error('编辑配置时只能提交当前这一个 mcpServer');
+    return entries[0][1];
+  }
+  throw new Error('期望 { connections: [...] } 或 { mcpServers: {...} }');
+}
+
+function existingHeaderValue(record, key) {
+  const direct = Object.entries(record.headers ?? {}).find(([name]) => name.toLowerCase() === key.toLowerCase());
+  if (direct) return direct[1];
+  if (key.toLowerCase() === 'authorization' && record.auth?.mode === 'bearer') {
+    return `Bearer ${record.auth.bearerToken}`;
+  }
+  if (record.auth?.mode === 'api-key' && record.auth.apiKeyHeader?.toLowerCase() === key.toLowerCase()) {
+    return record.auth.apiKeyValue;
+  }
+  return undefined;
+}
+
+function replaceKeepMarkers(document, current) {
+  const item = singleConfig(document);
+  if (!item || typeof item !== 'object' || Array.isArray(item)) throw new Error('连接配置必须是 JSON 对象');
+
+  if (item.url === KEEP_EXISTING_VALUE) {
+    if (!current.url) throw new Error('url 没有可保留的原值，请填写新值');
+    item.url = current.url;
+  }
+  if (item.command === KEEP_EXISTING_VALUE) {
+    if (!current.command) throw new Error('command 没有可保留的原值，请填写新值');
+    item.command = current.command;
+  }
+  if (Array.isArray(item.args) && item.args.length === 1 && item.args[0] === KEEP_EXISTING_VALUE) {
+    item.args = [...(current.args ?? [])];
+  }
+  if (item.cwd === KEEP_EXISTING_VALUE) item.cwd = current.cwd ?? '';
+
+  for (const [key, value] of Object.entries(item.headers ?? {})) {
+    if (value !== KEEP_EXISTING_VALUE) continue;
+    const existing = existingHeaderValue(current, key);
+    if (existing === undefined) throw new Error(`Header ${key} 没有可保留的原值，请填写新值`);
+    item.headers[key] = existing;
+  }
+  for (const [key, value] of Object.entries(item.env ?? {})) {
+    if (value !== KEEP_EXISTING_VALUE) continue;
+    if (current.env?.[key] === undefined) throw new Error(`环境变量 ${key} 没有可保留的原值，请填写新值`);
+    item.env[key] = current.env[key];
+  }
+  if (item.bearerToken === KEEP_EXISTING_VALUE) {
+    if (current.auth?.mode !== 'bearer' || !current.auth.bearerToken) throw new Error('Bearer Token 没有可保留的原值，请填写新值');
+    item.bearerToken = current.auth.bearerToken;
+  }
+  if (item.apiKeyValue === KEEP_EXISTING_VALUE) {
+    if (current.auth?.mode !== 'api-key' || current.auth.apiKeyValue === undefined || current.auth.apiKeyValue === '') {
+      throw new Error('API Key 没有可保留的原值，请填写新值');
+    }
+    item.apiKeyValue = current.auth.apiKeyValue;
+  }
+}
+
+function findKeepMarkers(value, path = '$', output = []) {
+  if (value === KEEP_EXISTING_VALUE) output.push(path);
+  else if (Array.isArray(value)) value.forEach((item, index) => findKeepMarkers(item, `${path}[${index}]`, output));
+  else if (value && typeof value === 'object') {
+    for (const [key, item] of Object.entries(value)) findKeepMarkers(item, `${path}.${key}`, output);
+  }
+  return output;
+}
+
+/**
+ * 把编辑器 JSON 合并为一条新的 ConnectionRecord。
+ * key / serverName / connectorId / kind / enabled / scope 均由旧记录锁定。
+ */
+export function normalizeConnectionReconfiguration(current, input) {
+  if (!connectionConfigurationEditable(current)) {
+    throw new Error('仅用户自定义或 JSON 导入的连接可编辑配置；市场连接器请使用配置或重新授权入口');
+  }
+  const document = parseInput(input);
+  replaceKeepMarkers(document, current);
+  const unresolved = findKeepMarkers(document);
+  if (unresolved.length > 0) throw new Error(`存在无法识别的保留标记：${unresolved.slice(0, 3).join('、')}`);
+
+  const { records, skipped } = normalizeJsonImport(document);
+  if (records.length !== 1 || skipped.length > 0) throw new Error('编辑配置时必须提交且只能提交当前这一条有效连接');
+  const parsed = records[0];
+  if (parsed.serverName !== current.serverName) {
+    throw new Error(`serverName 是连接身份，不能从 "${current.serverName}" 修改为 "${parsed.serverName}"；请新建连接`);
+  }
+  parsed.name = normalizeConnectionDisplayName(parsed.name);
+  if (parsed.auth?.mode === 'bearer' && !parsed.auth.bearerToken) throw new Error('Bearer Token 必填，或使用保留标记');
+  if (parsed.auth?.mode === 'api-key' && (parsed.auth.apiKeyValue === undefined || parsed.auth.apiKeyValue === '')) {
+    throw new Error('API Key 必填，或使用保留标记');
+  }
+
+  const stdio = parsed.transport === 'stdio';
+  return {
+    ...parsed,
+    key: current.key,
+    connectorId: current.connectorId,
+    kind: current.kind,
+    serverKey: current.serverKey,
+    enabled: current.enabled !== false,
+    createdAt: current.createdAt,
+    updatedAt: Date.now(),
+    lastError: undefined,
+    ...(stdio
+      ? { url: undefined, allowInsecurePrivateNetwork: undefined, headers: {}, auth: undefined }
+      : { command: undefined, args: undefined, env: undefined, cwd: undefined }),
+  };
+}

package/lib/index.js

@@ -7,7 +7,7 @@
  *   - 连接记录与 OAuth grant 持久化，重启恢复与跨 Host Token 轮换
  *   - 通过 ctx.loader 动态配置 @deepseek-ai/dsh-mcp-client 条目
  *   - 对话工具：mcp_connector_catalog / connect / configure / import_json /
- *     export_config / snapshots / install_from_url / status / set_enabled /
+ *     export_config / snapshots / install_from_url / status / rename / set_enabled /
  *     disconnect / refresh_catalog / publish
  */
 import { randomUUID } from 'node:crypto';
@@ -29,6 +29,11 @@ import { loadBundledCatalog, fetchRemoteCatalogWithFallback, mergeCatalog, listC
 import { describeOAuthAuthorizationError, oauthAuthorize } from './connectors/oauth-connector.js';
 import { buildManualRecord } from './connectors/manual-connector.js';
 import { normalizeJsonImport } from './connectors/json-connector.js';
+import {
+  connectionConfigurationEditable,
+  editableConnectionConfiguration,
+  normalizeConnectionReconfiguration,
+} from './connection-editor.js';
 import { discoverServerMetadata, refreshAccessToken, revokeRefreshToken, extractTokenResources } from './oauth.js';
 import { provision, disable, remove, entryIdFor } from './mcp-provision.js';
 import { classifyConnectionError, validateConnectionRecords } from './mcp-validation.js';
@@ -36,7 +41,7 @@ import { listMcpTools, McpHttpError } from './mcp-http.js';
 import { registerTools } from './tools.js';
 import { mountWebRoutes } from './web.js';
 import { createVersionStatusService } from './version-status.js';
-import { assertSafeUrl } from './util.js';
+import { assertSafeUrl, normalizeConnectionDisplayName } from './util.js';
 import { readLegacyGrantCandidates, planLegacyMigration, toConnectorGrant, toConnectionRecords } from './migration.js';
 import { classifyRefreshFailure, refreshRetryDelay } from './grant-lifecycle.js';
 import { buildHealthSummary, diagnosticForRecord } from './diagnostics.js';
@@ -575,6 +580,10 @@ export async function apply(ctx, config) {
     if (record?.connectorId) state.health.delete(record.connectorId);
   }
 
+  function connectionDisplayNameEditable(record) {
+    return connectionConfigurationEditable(record);
+  }
+
   async function persistRecord(record) {
     // 存储成功后才更新内存，避免落盘失败却在当前进程显示为“已安装”。
     if (config.persistSecrets) await connectionStore.put(record);
@@ -2200,6 +2209,8 @@ export async function apply(ctx, config) {
           name: record.name,
           connectorId: record.connectorId,
           kind: record.kind,
+          canRename: connectionDisplayNameEditable(record),
+          canEditConfiguration: connectionConfigurationEditable(record),
           serverName: record.serverName,
           url: record.url,
           transport: record.transport,
@@ -2362,6 +2373,101 @@ export async function apply(ctx, config) {
       };
     },
 
+    async renameConnection(key, name) {
+      const record = state.connections.get(key);
+      if (!record) return { ok: false, message: `连接 "${key}" 不存在` };
+      if (!connectionDisplayNameEditable(record)) {
+        return { ok: false, message: '仅用户自定义或 JSON 导入的连接可修改显示名；市场连接器名称由目录维护' };
+      }
+
+      let nextName;
+      try {
+        nextName = normalizeConnectionDisplayName(name);
+      } catch (error) {
+        return { ok: false, message: `重命名失败: ${error.message}` };
+      }
+      if (nextName === record.name) {
+        return {
+          ok: true,
+          message: `连接显示名未变更："${record.name}"`,
+          detail: { key: record.key, name: record.name, serverName: record.serverName, unchanged: true, snapshotId: null },
+        };
+      }
+
+      let snapshot;
+      try {
+        snapshot = await captureConnectionSnapshot('rename', [key]);
+        const next = { ...record, name: nextName, updatedAt: Date.now() };
+        const persisted = config.persistSecrets ? await connectionStore.put(next) : next;
+        state.connections.set(key, persisted);
+        return {
+          ok: true,
+          message: `已将连接显示名修改为 "${persisted.name}"`,
+          detail: {
+            key: persisted.key,
+            name: persisted.name,
+            serverName: persisted.serverName,
+            enabled: persisted.enabled !== false,
+            snapshotId: snapshot?.key ?? null,
+          },
+        };
+      } catch (error) {
+        await discardConnectionSnapshot(snapshot);
+        return { ok: false, message: `重命名失败，已保留原显示名: ${error.message}` };
+      }
+    },
+
+    async editableConnectionConfig(key) {
+      const record = state.connections.get(key);
+      if (!record) return { ok: false, message: `连接 "${key}" 不存在` };
+      try {
+        return {
+          ok: true,
+          message: `已生成 "${record.name}" 的安全可编辑配置；保留标记将在本机合并，不会返回已有敏感值`,
+          detail: editableConnectionConfiguration(record),
+        };
+      } catch (error) {
+        return { ok: false, message: `读取可编辑配置失败: ${error.message}` };
+      }
+    },
+
+    async reconfigureConnection(key, json) {
+      const current = state.connections.get(key);
+      if (!current) return { ok: false, message: `连接 "${key}" 不存在` };
+      try {
+        const next = normalizeConnectionReconfiguration(current, json);
+        const validation = await validateConnectionRecords([next], { timeoutMs: config.requestTimeoutMs });
+        if (!validation.ok) {
+          return {
+            ...validation,
+            message: `${validation.message.replace(/。未保存连接，请修正后重试。$/, '')}。已保留原连接和配置，请修正后重试。`,
+          };
+        }
+        const { committed: [committed], snapshot } = await commitWithSnapshot([next], 'reconfigure');
+        if (committed.connectorId && committed.enabled !== false) {
+          cacheHealth(committed.connectorId, [committed], readinessResults([committed], validation.detail.results));
+        }
+        return {
+          ok: true,
+          message: committed.enabled === false
+            ? `已保存 "${committed.name}" 的配置；连接保持停用`
+            : `已保存并重新连接 "${committed.name}"`,
+          detail: {
+            key: committed.key,
+            name: committed.name,
+            serverName: committed.serverName,
+            transport: committed.transport,
+            enabled: committed.enabled !== false,
+            snapshotId: snapshot?.key ?? null,
+          },
+        };
+      } catch (error) {
+        return error?.connectionRecord
+          ? connectionSetupFailure(error, '更新配置失败', '已保留原连接和配置，请修正后重试')
+          : { ok: false, message: `更新配置失败，已保留原连接和配置: ${error.message}` };
+      }
+    },
+
     async setEnabled(key, enabled) {
       const record = state.connections.get(key);
       if (!record) return { ok: false, message: `连接 "${key}" 不存在` };

package/lib/tools.js

@@ -1,5 +1,5 @@
 /**
- * 对话工具面：目录 / 连接 / 配置 / 导入 / 脱敏导出 / 快照 / URL 安装 / 状态 / 启停 / 断开 / 刷新目录 / 上下架。
+ * 对话工具面：目录 / 连接 / 配置 / 导入 / 安全编辑 / 脱敏导出 / 快照 / URL 安装 / 状态 / 启停 / 断开 / 刷新目录 / 上下架。
  */
 const RESULT_SCHEMA = {
   type: 'object',
@@ -469,6 +469,62 @@ export function registerTools(ctx, api) {
     },
   });
 
+  reg({
+    name: 'mcp_connector_rename',
+    description:
+      '修改用户自定义或 JSON 导入 MCP 连接的显示名。不改变 connection key、serverName、工具前缀、运行状态或凭据。',
+    parameters: {
+      type: 'object',
+      properties: {
+        key: { type: 'string', description: '连接 key（来自 mcp_connector_status）' },
+        name: { type: 'string', description: '新的连接显示名，最长 80 个字符' },
+      },
+      required: ['key', 'name'],
+      additionalProperties: false,
+    },
+    output: resultOutput,
+    async execute(args) {
+      return api.renameConnection(args.key, args.name);
+    },
+  });
+
+  reg({
+    name: 'mcp_connector_get_editable_config',
+    description:
+      '读取用户自定义或 JSON 导入连接的标准化可编辑 JSON。已有敏感值只返回 <KEEP_EXISTING> 保留标记，不会返回真实凭据、本地参数或路径。',
+    parameters: {
+      type: 'object',
+      properties: {
+        key: { type: 'string', description: '连接 key（来自 mcp_connector_status）' },
+      },
+      required: ['key'],
+      additionalProperties: false,
+    },
+    output: exportOutput,
+    async execute(args) {
+      return api.editableConnectionConfig(args.key);
+    },
+  });
+
+  reg({
+    name: 'mcp_connector_reconfigure',
+    description:
+      '校验并原子更新一条用户自定义或 JSON 导入连接。serverName 和连接身份不可修改；<KEEP_EXISTING> 在本机合并，失败时保留原连接。',
+    parameters: {
+      type: 'object',
+      properties: {
+        key: { type: 'string', description: '连接 key（来自 mcp_connector_status）' },
+        json: { type: 'string', description: '修改后的单连接 JSON，可使用 get_editable_config 返回的保留标记' },
+      },
+      required: ['key', 'json'],
+      additionalProperties: false,
+    },
+    output: resultOutput,
+    async execute(args) {
+      return api.reconfigureConnection(args.key, args.json);
+    },
+  });
+
   reg({
     name: 'mcp_connector_disconnect',
     description: '断开并移除一条 MCP 连接；OAuth 连接会按引用计数撤销 refresh_token（无其他连接引用该授权时）。',

package/lib/util.js

@@ -52,6 +52,15 @@ export function slugServerName(input) {
   return slug;
 }
 
+/** 归一化用户可编辑的连接显示名；不用于 serverName / 工具前缀。 */
+export function normalizeConnectionDisplayName(input) {
+  const name = String(input ?? '').trim();
+  if (!name) throw new Error('连接显示名不能为空');
+  if (/[\u0000-\u001f\u007f]/.test(name)) throw new Error('连接显示名不能包含控制字符');
+  if ([...name].length > 80) throw new Error('连接显示名不能超过 80 个字符');
+  return name;
+}
+
 function parseUrl(rawUrl) {
   let url;
   try {

package/lib/web.js

@@ -41,6 +41,9 @@ const API_WHITELIST = new Map([
   ['previewSnapshot', (api, p) => api.previewSnapshot(p?.snapshotId)],
   ['restoreSnapshot', (api, p) => api.restoreSnapshot(p?.snapshotId)],
   ['installFromUrl', (api, p) => api.installFromUrl(p?.url, p ?? {})],
+  ['renameConnection', (api, p) => api.renameConnection(p?.key, p?.name)],
+  ['editableConnectionConfig', (api, p) => api.editableConnectionConfig(p?.key)],
+  ['reconfigureConnection', (api, p) => api.reconfigureConnection(p?.key, p?.json)],
   ['disconnect', (api, p) => api.disconnect(p?.key)],
   ['setEnabled', (api, p) => api.setEnabled(p?.key, p?.enabled !== false)],
   ['refreshCatalog', (api) => api.refreshCatalog()],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mcp-connector",
-  "version": "0.2.39",
+  "version": "0.2.41",
   "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",
@@ -41,7 +41,7 @@
   ],
   "scripts": {
     "test": "node --test",
-    "lint": "node --check lib/index.js && node --check lib/web.js && node --check lib/client.js && node --check lib/settings.js && node --check lib/version-status.js && node --check lib/schema.js && node --check lib/catalog.js && node --check lib/prompts.js && node --check lib/probe.js && node --check lib/diagnostics.js && node --check lib/connection-backup.js && node --check lib/connection-scopes.js && node --check lib/governance.js && node --check lib/mcp-validation.js && node --check lib/mcp-http.js && node --check lib/migration.js && node --check lib/stores.js && node --check lib/grant-journal.js && node --check lib/oauth.js && node --check lib/grant-lifecycle.js && node --check lib/callback-server.js && node --check lib/mcp-provision.js && node --check lib/util.js && node --check lib/constants.js && node --check lib/tools.js && node --check lib/connectors/oauth-connector.js && node --check lib/connectors/manual-connector.js && node --check lib/connectors/json-connector.js && node --check scripts/probe-connector.mjs && node --check scripts/build-registry.mjs && node --check scripts/ui-harness.mjs && node --check scripts/check-market-registration.mjs && node --check scripts/check-readme-version.mjs && node --check scripts/check-marketing-metadata.mjs && node --check scripts/check-storefront-screenshots.mjs && node --check scripts/sync-registry-stats.mjs && node --check scripts/verify-pack.mjs",
+    "lint": "node --check lib/index.js && node --check lib/web.js && node --check lib/client.js && node --check lib/settings.js && node --check lib/version-status.js && node --check lib/schema.js && node --check lib/catalog.js && node --check lib/prompts.js && node --check lib/probe.js && node --check lib/diagnostics.js && node --check lib/connection-backup.js && node --check lib/connection-editor.js && node --check lib/connection-scopes.js && node --check lib/governance.js && node --check lib/mcp-validation.js && node --check lib/mcp-http.js && node --check lib/migration.js && node --check lib/stores.js && node --check lib/grant-journal.js && node --check lib/oauth.js && node --check lib/grant-lifecycle.js && node --check lib/callback-server.js && node --check lib/mcp-provision.js && node --check lib/util.js && node --check lib/constants.js && node --check lib/tools.js && node --check lib/connectors/oauth-connector.js && node --check lib/connectors/manual-connector.js && node --check lib/connectors/json-connector.js && node --check scripts/probe-connector.mjs && node --check scripts/build-registry.mjs && node --check scripts/ui-harness.mjs && node --check scripts/check-market-registration.mjs && node --check scripts/check-readme-version.mjs && node --check scripts/check-marketing-metadata.mjs && node --check scripts/check-storefront-screenshots.mjs && node --check scripts/sync-registry-stats.mjs && node --check scripts/verify-pack.mjs",
     "registry:build": "node scripts/build-registry.mjs",
     "registry:validate": "node scripts/probe-connector.mjs catalog/catalog.json --validate-only",
     "dev:ui": "node scripts/ui-harness.mjs",

package/ui/index.html

@@ -394,6 +394,7 @@
   .inline-error { color: var(--bad); background: var(--bad-bg); border-radius: 7px; padding: 8px 10px; margin-top: 12px; font-size: 12px; display: none; }
   .inline-error.show { display: block; }
   #backup-json { height: 190px; resize: vertical; font: 11px/1.5 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; }
+  #edit-connection-json { height: 260px; resize: vertical; font: 11px/1.5 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; }
   .snapshot-list { border: 1px solid var(--line); border-radius: 9px; margin-top: 8px; max-height: 210px; overflow-y: auto; }
   .snapshot-item { display: flex; align-items: center; gap: 10px; padding: 9px 10px; border-top: 1px solid var(--line); }
   .snapshot-item:first-child { border-top: 0; }
@@ -498,6 +499,7 @@
     connect: 145_000,
     configure: 145_000,
     importJson: 145_000,
+    reconfigureConnection: 145_000,
     installFromUrl: 145_000,
     setEnabled: 130_000,
     restoreSnapshot: 145_000,
@@ -1111,6 +1113,8 @@
 
   function rowHtml(r) {
     const key = esc(r.key);
+    const canRename = r.canRename === true;
+    const canEditConfiguration = r.canEditConfiguration === true;
     const authMode = r.authMode === 'oauth' ? '<span class="badge auth-oauth">OAuth</span>' : `<span class="badge">${esc(r.authMode || 'manual')}</span>`;
     const healthLabels = { healthy: '已连接', unknown: '状态未知', configured: '已配置', reauth: '需重新授权', recovering: '自动重试中', degraded: '部分异常', unavailable: '连接异常', disabled: '已停用' };
     const healthClass = r.connectionState === 'healthy' ? 'pass' : ['reauth', 'recovering', 'degraded'].includes(r.connectionState) ? 'partial' : r.connectionState === 'unavailable' ? 'fail' : '';
@@ -1131,6 +1135,8 @@
         <input type="checkbox" ${enabled ? 'checked' : ''} onchange="window.__mcp.toggle('${key}', this.checked)">
         <span class="slider"></span>
       </label>
+      ${canEditConfiguration ? `<button class="btn ghost" type="button" onclick="window.__mcp.openEditor('${key}')">编辑配置</button>` : ''}
+      ${canRename ? `<button class="btn ghost" type="button" onclick="window.__mcp.openRename('${key}')">重命名</button>` : ''}
       <button class="btn ghost" type="button" onclick="window.__mcp.openScope('${key}')">范围</button>
       <button class="btn danger" onclick="window.__mcp.disconnect('${key}')">断开</button>
     </div>`;
@@ -1244,6 +1250,36 @@
       <div class="m-actions"><button class="btn ghost" type="button" onclick="window.__mcp.closeModal()">取消</button><button class="btn" type="button" onclick="window.__mcp.submitScopeChange()">预览并应用</button></div>`);
   }
 
+  function openRenameConnection(key) {
+    const item = installedItems.find((candidate) => candidate.key === key);
+    if (!item) { showToast('连接不存在，请刷新后重试', false); return; }
+    if (item.canRename !== true) {
+      showToast('市场连接器名称由目录维护', false);
+      return;
+    }
+    openModal('修改连接显示名', `
+      <div class="form-note"><strong>只修改页面显示名</strong>当前连接不会中断；<code>serverName</code>、工具前缀、作用范围和凭据均保持不变。</div>
+      <label for="rename-name">连接显示名（必填）</label><input id="rename-name" value="${esc(item.name)}" maxlength="80" autocomplete="off" />
+      <label for="rename-server-name">serverName（工具前缀，不可修改）</label><input id="rename-server-name" value="${esc(item.serverName || '')}" disabled />
+      <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.submitRename('${esc(key)}')">保存显示名</button></div>`);
+  }
+
+  async function openConnectionEditor(key) {
+    const item = installedItems.find((candidate) => candidate.key === key);
+    if (!item) { showToast('连接不存在，请刷新后重试', false); return; }
+    const result = await call('editableConnectionConfig', { key });
+    if (!result.ok) { showToast(result.message, false); return; }
+    const action = item.enabled === false ? '保存配置' : '保存并重连';
+    openModal(`编辑配置 · ${item.name}`, `
+      <div class="form-note"><strong>安全编辑标准化 JSON</strong><code>serverName</code> 是连接身份，不可修改；原始排版、注释和字段别名不会被还原。<code>&lt;KEEP_EXISTING&gt;</code> 表示敏感值继续留在本机，可直接保留，或替换为新值；删除字段表示清除该项。</div>
+      <div class="field-label-row"><label for="edit-connection-json">单连接 JSON</label><button class="text-btn" type="button" onclick="window.__mcp.formatEditJson()">格式化 JSON</button></div>
+      <textarea id="edit-connection-json" rows="14" spellcheck="false">${esc(result.detail?.json || '')}</textarea>
+      <div class="field-help">提交前会先验证新配置并创建快照。任何校验、启动或保存失败都会保留原连接；连接 key、作用范围与启停状态不变。</div>
+      <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.submitReconfigure('${esc(key)}')">${action}</button></div>`);
+  }
+
   function openAddConnection(mode = 'json', preset = {}) {
     const server = (preset.servers || [{}])[0] || {};
     if (mode === 'manual' && preset.id && ['bearer', 'api-key'].includes(preset.authMode)) {
@@ -1371,6 +1407,48 @@
       if (connectorId) return window.__mcp.connect(connectorId);
     },
     openScope(key) { openScopeManager(key); },
+    openRename(key) { openRenameConnection(key); },
+    async openEditor(key) { await openConnectionEditor(key); },
+    formatEditJson() {
+      const input = $('#edit-connection-json');
+      if (!input) return;
+      try {
+        input.value = JSON.stringify(JSON.parse(input.value), null, 2);
+        $('#modal-error')?.classList.remove('show');
+      } catch (error) {
+        showModalError(`JSON 格式化失败: ${error.message}`);
+      }
+    },
+    async submitReconfigure(key) {
+      const input = $('#edit-connection-json');
+      if (!input?.value.trim()) { showModalError('连接配置不能为空'); return; }
+      let json;
+      try {
+        json = JSON.stringify(JSON.parse(input.value), null, 2);
+        input.value = json;
+      } catch (error) {
+        showModalError(`连接配置不是合法 JSON: ${error.message}`);
+        return;
+      }
+      setModalBusy(true, '正在校验并更新…');
+      const result = await call('reconfigureConnection', { key, json });
+      setModalBusy(false);
+      if (!result.ok) { showModalError(result.message); return; }
+      closeModal();
+      showToast(result.message, true);
+      await loadInstalled();
+    },
+    async submitRename(key) {
+      const name = $('#rename-name')?.value.trim() || '';
+      if (!name) { showModalError('连接显示名不能为空'); return; }
+      setModalBusy(true);
+      const result = await call('renameConnection', { key, name });
+      setModalBusy(false);
+      if (!result.ok) { showModalError(result.message); return; }
+      closeModal();
+      showToast(result.message, true);
+      await loadInstalled();
+    },
     async submitScopeChange() {
       if (!pendingScopeKey) return;
       let target;