dsh-mcp-connector 0.2.22 → 0.2.23

package/CHANGELOG.md

@@ -4,6 +4,19 @@
 
 ## [Unreleased]
 
+## [0.2.23] - 2026-08-26
+
+### Fixed
+
+- OAuth Grant 现在保存 Access Token 的真实过期时间，并在提前刷新遇到网络、发现端点或服务端暂时故障时采用有上限的指数退避自动恢复；只有 `invalid_grant`、`invalid_client` 等明确不可恢复错误才显示“需重新授权”。
+- 启动恢复不再吞掉 Token 刷新异常；脱敏日志会记录阶段、OAuth 错误码、HTTP 状态与永久/暂时分类，且不会输出 Access Token、Refresh Token 或客户端密钥。
+- `grantSharing: "issuer"` 正式生效：同账号、同 issuer/scope 的卡片共享动态客户端与 Grant，后续连接同组卡片不再重复打开授权页；重新授权会把同组已连接卡片迁移到新 Grant。
+- 启动和连接前检测仍启用的 `qcc-mcp-oauth` / `qcc-legal-mcp-oauth` 及其残留 mcp-client 条目；发现同名 Server 时阻断新连接，避免旧 Token 覆盖新连接器凭据。
+
+### Verification
+
+- 新增 OAuth 刷新失败分类/脱敏/退避、暂时故障自动恢复、永久失效重新授权、同 issuer 顺序与并发共享授权、旧插件冲突阻断回归测试。
+
 ## [0.2.22] - 2026-08-26
 
 ### Fixed
@@ -372,7 +385,8 @@
 - 外部 URL 与导入 Header 执行安全校验。
 - iframe 消息校验同源和消息来源。
 
-[Unreleased]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.22...HEAD
+[Unreleased]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.23...HEAD
+[0.2.23]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.22...v0.2.23
 [0.2.22]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.21...v0.2.22
 [0.2.21]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.20...v0.2.21
 [0.2.20]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.19...v0.2.20

package/README.en.md

@@ -25,10 +25,10 @@ Browse and install MCP connectors from different providers in DeepSeek Harness D
 - 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. DCR client secrets are kept with the local grant only.
+- 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; DCR client secrets remain local to that grant.
 - 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.
+- 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-08-25, the public Registry publishes 78 connector descriptors. After merging and deduplicating them with the 4 bundled Qichacha cards, the Marketplace exposes 82 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.

package/README.md

@@ -25,11 +25,11 @@
 - Prompt 模板：使用 `{{company}}` 等变量，发送前填写真实查询主体。
 - 三种接入：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 一同只保存在本机。
+- 生命周期管理：连接持久化、重启恢复、启停、断开、OAuth 自动刷新/退避恢复与撤销；同 issuer 卡片可共享一次授权，DCR 返回的客户端密钥与 Token 一同只保存在本机。
 - 目录运营：内置目录、远程 registry、本地覆盖，支持 `published` 上下架与 `featured` 精选。
 - 独立远程 Registry：新市场卡片合并后客户端刷新即可见，无需重新发布 npm；远程不可用时自动回退内置目录。
 - Registry 工具链：Schema/唯一性/密钥审计、MCP/OAuth 无凭据探针、每周健康巡检。
-- 平滑迁移：显式扫描并复制两个旧企查查 OAuth 插件授权；不删除原插件或原凭据。
+- 平滑迁移：显式扫描并复制两个旧企查查 OAuth 插件授权；检测到旧插件仍启用并管理同名 Server 时阻断重复连接，避免凭据相互覆盖。
 - 对话工具：`mcp_connector_catalog`、`connect`、`configure`、`import_json`、`install_from_url`、`status`、`health_check`、`set_enabled`、`disconnect`、`refresh_catalog`、`publish`、`tools_list`。
 
 <!-- catalog-stats:start -->

package/docs/USER-GUIDE.md

@@ -63,6 +63,7 @@ dsh web
 | `连接` | OAuth 或免密连接器尚未连接 | 点击后按页面提示完成授权或连通性检查 |
 | `配置` | 需要 Bearer Token 或 API Key | 录入服务商签发的凭据并验证 |
 | `需重新授权` | OAuth 授权过期、被撤销或不可用 | 点击后重新完成 OAuth 授权 |
+| `自动重试中` | OAuth Token 刷新遇到网络或服务端暂时故障 | 无需重新授权；保持 DSH 运行，插件会按退避策略自动恢复 |
 | `已配置` | 本机已有配置，尚未完成本轮健康确认 | 点击“刷新”或进入详情检查 |
 | `已连接` | 最近一次健康检查通过 | 可直接在会话中使用对应 MCP 工具 |
 | `部分异常` / `连接异常` | 一个或多个 Server 未通过检查 | 打开详情查看提示，核对网络、权限和服务状态 |
@@ -73,6 +74,8 @@ stdio 市场卡片也可能显示一个或多个凭据字段，例如 API Token
 
 OAuth 一键连接要求服务商支持标准 OAuth 2.1/PKCE 和公开元数据发现。动态客户端注册既支持无需客户端密钥的 `none`，也支持服务商签发密钥的 `client_secret_post` 与 `client_secret_basic`。客户端密钥仅与 OAuth Grant 一同保存在 DSH 本机，用于换取、刷新和撤销 Token；插件不会要求用户把 OAuth Token 或客户端密钥复制到聊天中。
 
+当市场描述声明 `grantSharing: "issuer"` 时，同一账号下相同 issuer、scope 和客户端鉴权方式的卡片共享一组 Grant。首次授权仍只启用用户点击的卡片；之后连接同组卡片会直接复用现有授权，不再重复打开 OAuth 页面。网络、OAuth 元数据发现或服务端 5xx 等暂时故障只进入“自动重试中”，明确收到 Refresh Token/客户端失效错误时才进入“需重新授权”。
+
 ## 5. 查看详情、Prompt 与工具
 
 点击卡片或“详情”可打开连接器详情：

package/lib/connectors/oauth-connector.js

@@ -80,12 +80,19 @@ export async function oauthAuthorize({ connector, config, logger, signal }) {
   // 按 token 实际授权范围过滤 server；非 JWT / 无 resource claim 时 fallback 全部
   const grantedUrls = extractTokenResources(token.accessToken);
   let grantedKeys;
+  let grantedResources;
   if (grantedUrls) {
     const granted = new Set(grantedUrls);
-    grantedKeys = connector.servers.filter((s) => granted.has(s.url)).map((s) => s.serverKey);
-    if (grantedKeys.length === 0) grantedKeys = [entryServer.serverKey];
+    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);
   }
 
   return {
@@ -98,6 +105,7 @@ export async function oauthAuthorize({ connector, config, logger, signal }) {
     scope: connector.auth.scope,
     token,
     grantedKeys,
+    grantedResources,
     entryResource,
   };
 }

package/lib/constants.js

@@ -30,6 +30,9 @@ export const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
 /** 首次启动 MCP Server 并完成 initialize + tools/list 的最长等待时间 */
 export const DEFAULT_STARTUP_TIMEOUT_MS = 120_000;
 export const DEFAULT_REFRESH_SKEW_MS = 300_000;
+/** OAuth 刷新暂时失败后的指数退避范围。 */
+export const DEFAULT_REFRESH_RETRY_BASE_MS = 30_000;
+export const DEFAULT_REFRESH_RETRY_MAX_MS = 300_000;
 export const DEFAULT_CATALOG_TTL_MS = 3_600_000;
 
 /** PKCE 约束（RFC 7636） */

package/lib/grant-lifecycle.js

@@ -0,0 +1,47 @@
+/** OAuth Grant 刷新失败分类、日志脱敏与重试退避。 */
+
+const PERMANENT_REFRESH_CODES = new Set([
+  'invalid_grant',
+  'invalid_token',
+  'invalid_client',
+  'unauthorized_client',
+  'invalid_scope',
+  'client_secret_expired',
+  'missing_refresh_token',
+]);
+
+/** 防止 OAuth 服务端错误描述意外回显凭据。 */
+export function redactOAuthDetail(value) {
+  return String(value ?? '')
+    .replace(/\bBearer\s+[^\s,;]+/gi, 'Bearer [REDACTED]')
+    .replace(/([?&](?:access_token|refresh_token|client_secret|code)=)[^&#\s]*/gi, '$1[REDACTED]')
+    .replace(/((?:access_token|refresh_token|client_secret)\s*[=:]\s*)[^\s,;&}]+/gi, '$1[REDACTED]')
+    .slice(0, 500);
+}
+
+/**
+ * 只有明确表示 Refresh Token / 动态客户端不可恢复的 OAuth 错误才要求重新授权。
+ * 网络、发现端点、5xx、超时和未知服务端错误都按暂时故障自动重试。
+ */
+export function classifyRefreshFailure(error) {
+  const code = typeof error?.code === 'string' && error.code
+    ? redactOAuthDetail(error.code).slice(0, 80)
+    : error?.name === 'OAuthNetworkError' ? 'network_error' : 'refresh_failed';
+  const httpStatus = Number.isInteger(error?.httpStatus) ? error.httpStatus : undefined;
+  const permanent = PERMANENT_REFRESH_CODES.has(code) || httpStatus === 401 || httpStatus === 403;
+  return {
+    permanent,
+    kind: permanent ? 'permanent' : 'transient',
+    code,
+    httpStatus,
+    message: redactOAuthDetail(error?.message || code),
+  };
+}
+
+/** 指数退避：base、2×、4×……，封顶 max。failureCount 从 1 开始。 */
+export function refreshRetryDelay(failureCount, baseMs, maxMs) {
+  const base = Math.max(1_000, Number(baseMs) || 30_000);
+  const max = Math.max(base, Number(maxMs) || 300_000);
+  const exponent = Math.max(0, Math.min(20, Number(failureCount || 1) - 1));
+  return Math.min(max, base * (2 ** exponent));
+}

package/lib/index.js

@@ -17,6 +17,8 @@ import {
   DEFAULT_REQUEST_TIMEOUT_MS,
   DEFAULT_STARTUP_TIMEOUT_MS,
   DEFAULT_REFRESH_SKEW_MS,
+  DEFAULT_REFRESH_RETRY_BASE_MS,
+  DEFAULT_REFRESH_RETRY_MAX_MS,
   DEFAULT_CATALOG_TTL_MS,
 } from './constants.js';
 import { defineConnectorDomain, ConnectionStore, GrantStore, CatalogStore } from './stores.js';
@@ -25,7 +27,7 @@ import { loadBundledCatalog, fetchRemoteCatalogWithFallback, mergeCatalog, listC
 import { oauthAuthorize } from './connectors/oauth-connector.js';
 import { buildManualRecord } from './connectors/manual-connector.js';
 import { normalizeJsonImport } from './connectors/json-connector.js';
-import { discoverServerMetadata, refreshAccessToken, revokeRefreshToken } from './oauth.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';
 import { listMcpTools, McpHttpError } from './mcp-http.js';
@@ -33,9 +35,21 @@ import { registerTools } from './tools.js';
 import { mountWebRoutes } from './web.js';
 import { assertSafeUrl } from './util.js';
 import { readLegacyGrantCandidates, planLegacyMigration, toConnectorGrant, toConnectionRecords } from './migration.js';
+import { classifyRefreshFailure, refreshRetryDelay } from './grant-lifecycle.js';
 
 export const name = 'mcp-connector';
 
+const LEGACY_OAUTH_PLUGINS = [
+  {
+    id: 'qcc-mcp-oauth',
+    servers: ['qcc-company', 'qcc-risk', 'qcc-ipr', 'qcc-operation', 'qcc-history', 'qcc-executive'],
+  },
+  {
+    id: 'qcc-legal-mcp-oauth',
+    servers: ['qcc-regulation', 'qcc-case'],
+  },
+];
+
 export const inject = ['tools', 'storageDomain', 'loader'];
 
 export const Config = z.object({
@@ -57,6 +71,10 @@ export const Config = z.object({
   startupTimeoutMs: z.number().default(DEFAULT_STARTUP_TIMEOUT_MS),
   /** 提前刷新阈值（ms） */
   refreshSkewMs: z.number().default(DEFAULT_REFRESH_SKEW_MS),
+  /** 刷新暂时失败后的首次重试间隔（ms） */
+  refreshRetryBaseMs: z.number().default(DEFAULT_REFRESH_RETRY_BASE_MS),
+  /** 刷新暂时失败后的最大重试间隔（ms） */
+  refreshRetryMaxMs: z.number().default(DEFAULT_REFRESH_RETRY_MAX_MS),
   /** 是否自动打开浏览器（false = 仅打印授权 URL） */
   openBrowser: z.boolean().default(true),
   /** 授权账号标识（预留多账号） */
@@ -81,9 +99,10 @@ export async function apply(ctx, config) {
     dynamic: new Map(),         // URL 安装的临时连接器
     overrides: new Map(),       // id -> { published?, featured? }
     connections: new Map(),     // key -> ConnectionRecord
-    grants: new Map(),          // grantKey -> { grant, timer, refreshPromise, needsReauth }
+    grants: new Map(),          // grantKey -> { grant, timer, refreshPromise, needsReauth, refreshFailure* }
     health: new Map(),          // connectorId -> 最近一次主动连通性检查摘要（不持久化）
-    oauthConnects: new Map(),   // connectorId -> 正在进行的 OAuth 授权 Promise（防重复弹窗/重复 grant）
+    oauthConnects: new Map(),   // sharingKey -> { promise, requestedConnectorIds }（防同 issuer 重复弹窗）
+    warnedLegacyConflicts: new Set(),
   };
 
   /* ───────────────────────── 目录加载 ───────────────────────── */
@@ -154,8 +173,91 @@ export async function apply(ctx, config) {
     await recomputeMerged();
   }
 
+  /* ───────────────────────── 旧 OAuth 插件冲突 ───────────────────────── */
+
+  function loaderEntryActive(id) {
+    try {
+      const entry = ctx.loader.resolve(id);
+      return !!entry && entry.disabled !== true && entry.options?.disabled !== true;
+    } catch {
+      return false;
+    }
+  }
+
+  function activeLegacyPlugin(definition) {
+    if (loaderEntryActive(definition.id)) return definition.id;
+    // 兼容旧插件本体已经移除、但其动态 mcp-client 条目仍残留的配置树。
+    return definition.servers.some((serverName) => loaderEntryActive(`mcp-${serverName}`))
+      ? definition.id
+      : null;
+  }
+
+  function legacyConflictForServer(serverName) {
+    for (const definition of LEGACY_OAUTH_PLUGINS) {
+      if (definition.servers.includes(serverName) && activeLegacyPlugin(definition)) return definition.id;
+    }
+    return null;
+  }
+
+  function legacyConflictForRecord(record) {
+    const pluginId = legacyConflictForServer(record?.serverName);
+    if (!pluginId) return null;
+    return {
+      pluginId,
+      serverName: record.serverName,
+      message: `检测到旧插件 ${pluginId} 仍在管理同名服务 ${record.serverName}；请停用旧插件并重启 DSH`,
+    };
+  }
+
+  function legacyConflictForConnector(connector) {
+    for (const server of connector?.servers ?? []) {
+      const pluginId = legacyConflictForServer(server.serverName);
+      if (pluginId) {
+        return {
+          pluginId,
+          serverName: server.serverName,
+          message: `检测到旧插件 ${pluginId} 仍在管理同名服务 ${server.serverName}；为避免凭据覆盖，请停用旧插件并重启 DSH 后再连接`,
+        };
+      }
+    }
+    return null;
+  }
+
+  function warnLegacyConflict(conflict) {
+    if (!conflict || state.warnedLegacyConflicts.has(conflict.pluginId)) return;
+    state.warnedLegacyConflicts.add(conflict.pluginId);
+    logger.warn(`legacy OAuth plugin conflict: ${conflict.message}`);
+  }
+
+  function detectLegacyPluginConflicts() {
+    const conflicts = [];
+    for (const definition of LEGACY_OAUTH_PLUGINS) {
+      if (!activeLegacyPlugin(definition)) continue;
+      const conflict = {
+        pluginId: definition.id,
+        message: `检测到旧插件 ${definition.id} 仍处于启用状态；它会与 MCP连接器重复管理企查查 Server`,
+      };
+      conflicts.push(conflict);
+      warnLegacyConflict(conflict);
+    }
+    return conflicts;
+  }
+
   /* ───────────────────────── grant 刷新 ───────────────────────── */
 
+  function grantRuntime(grant) {
+    return {
+      grant,
+      timer: undefined,
+      refreshPromise: null,
+      needsReauth: false,
+      refreshFailureKind: null,
+      refreshFailureCount: 0,
+      lastRefreshError: null,
+      refreshRetryAt: null,
+    };
+  }
+
   function grantMap() {
     const map = new Map();
     for (const [key, g] of state.grants) map.set(key, g.grant);
@@ -164,10 +266,16 @@ 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 || !entry.grant.refreshToken) {
+      const error = new Error('no refresh token available');
+      error.code = 'missing_refresh_token';
+      throw error;
+    }
     if (entry.grant.clientSecret && entry.grant.clientSecretExpiresAt > 0
         && entry.grant.clientSecretExpiresAt * 1000 <= Date.now()) {
-      throw new Error('OAuth dynamic client secret expired');
+      const error = new Error('OAuth dynamic client secret expired');
+      error.code = 'client_secret_expired';
+      throw error;
     }
     if (entry.refreshPromise) return entry.refreshPromise;
     entry.refreshPromise = (async () => {
@@ -177,22 +285,39 @@ export async function apply(ctx, config) {
         clientSecret: entry.grant.clientSecret,
         tokenEndpointAuthMethod: entry.grant.tokenEndpointAuthMethod ?? 'none',
         refreshToken: entry.grant.refreshToken,
-        resource: entry.grant.authorizedResources[0],
+        // 多资源共享 Grant 不应在刷新时被第一个 resource 意外收窄。
+        resource: entry.grant.authorizedResources.length === 1 ? entry.grant.authorizedResources[0] : undefined,
         scope: entry.grant.scope,
         timeoutMs: config.requestTimeoutMs,
       });
+      const refreshedResources = extractTokenResources(token.accessToken);
       const next = {
         ...entry.grant,
         accessToken: token.accessToken,
-        accessTokenExpiresAt: Date.now() + token.expiresIn * 1000 - config.refreshSkewMs,
+        // 持久化真实过期时间；提前刷新只用于定时调度，不能冒充 Token 已过期。
+        accessTokenExpiresAt: Date.now() + token.expiresIn * 1000,
         refreshToken: token.refreshToken ?? entry.grant.refreshToken,
+        authorizedResources: refreshedResources?.length ? refreshedResources : entry.grant.authorizedResources,
+        updatedAt: Date.now(),
       };
       entry.grant = next;
       entry.needsReauth = false;
+      entry.refreshFailureKind = null;
+      entry.refreshFailureCount = 0;
+      entry.lastRefreshError = null;
+      entry.refreshRetryAt = null;
       state.grants.set(grantKey, entry);
       if (config.persistSecrets) await grantStore.put(next);
       for (const [key, record] of state.connections) {
-        if (record.auth?.grantKey === grantKey) await provision(ctx, config, record, grantMap());
+        if (record.auth?.grantKey !== grantKey || record.enabled === false) continue;
+        const conflict = legacyConflictForRecord(record);
+        if (conflict) {
+          warnLegacyConflict(conflict);
+          continue;
+        }
+        await provision(ctx, config, record, grantMap()).catch((error) => {
+          logger.warn(`re-provision "${key}" after OAuth refresh failed: ${error.message}`);
+        });
       }
       scheduleRefresh(grantKey);
       return next;
@@ -204,20 +329,61 @@ export async function apply(ctx, config) {
     }
   }
 
-  function scheduleRefresh(grantKey) {
+  function scheduleRefresh(grantKey, { delayMs } = {}) {
     const entry = state.grants.get(grantKey);
     if (!entry) return;
     if (entry.timer) clearTimeout(entry.timer);
-    const delay = Math.max(0, entry.grant.accessTokenExpiresAt - Date.now());
+    const tokenLifetime = Math.max(0, entry.grant.accessTokenExpiresAt - (entry.grant.updatedAt || Date.now()));
+    const effectiveSkew = Math.min(
+      Math.max(0, config.refreshSkewMs),
+      Math.max(1_000, Math.floor(tokenLifetime * 0.1)),
+    );
+    const delay = delayMs === undefined
+      ? Math.max(0, entry.grant.accessTokenExpiresAt - effectiveSkew - Date.now())
+      : Math.max(0, delayMs);
     entry.timer = setTimeout(() => {
-      refreshGrant(grantKey).catch((error) => {
-        entry.needsReauth = true;
-        logger.warn(`grant ${grantKey} refresh failed: ${error.message}`);
-      });
+      entry.timer = undefined;
+      refreshGrantWithRecovery(grantKey, 'scheduled').catch(() => {});
     }, delay);
     entry.timer.unref?.();
   }
 
+  function recordRefreshFailure(grantKey, error, phase) {
+    const entry = state.grants.get(grantKey);
+    if (!entry) return classifyRefreshFailure(error);
+    const failure = classifyRefreshFailure(error);
+    entry.refreshFailureCount = (entry.refreshFailureCount ?? 0) + 1;
+    entry.refreshFailureKind = failure.kind;
+    entry.lastRefreshError = failure.message;
+    entry.needsReauth = failure.permanent;
+    entry.refreshRetryAt = null;
+
+    const status = failure.httpStatus ? ` http=${failure.httpStatus}` : '';
+    const action = failure.permanent ? 'reauthorization required' : 'automatic retry scheduled';
+    logger.warn(`OAuth grant refresh failed phase=${phase} grant=${grantKey} code=${failure.code}${status} classification=${failure.kind}: ${failure.message}; ${action}`);
+
+    if (!failure.permanent) {
+      const delay = refreshRetryDelay(
+        entry.refreshFailureCount,
+        config.refreshRetryBaseMs,
+        config.refreshRetryMaxMs,
+      );
+      entry.refreshRetryAt = Date.now() + delay;
+      scheduleRefresh(grantKey, { delayMs: delay });
+    }
+    return failure;
+  }
+
+  async function refreshGrantWithRecovery(grantKey, phase) {
+    try {
+      return await refreshGrant(grantKey);
+    } catch (error) {
+      // 多个调用方可能等待同一个 refreshPromise；同一次失败只能记一次并调度一个重试。
+      if (!error.refreshFailure) error.refreshFailure = recordRefreshFailure(grantKey, error, phase);
+      throw error;
+    }
+  }
+
   async function retireGrantIfUnused(grantKey, { revoke = false } = {}) {
     if ([...state.connections.values()].some((record) => record.auth?.grantKey === grantKey)) return false;
     const entry = state.grants.get(grantKey);
@@ -375,14 +541,30 @@ export async function apply(ctx, config) {
 
   function grantFailure(record) {
     if (record.auth?.mode !== 'oauth') return null;
+    const conflict = legacyConflictForRecord(record);
+    if (conflict) {
+      warnLegacyConflict(conflict);
+      return { ok: false, kind: 'conflict', serverKey: record.serverKey, serverName: record.serverName, message: conflict.message };
+    }
     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 授权缺失，请重新授权' };
     const clientSecretExpired = entry.grant.clientSecret && entry.grant.clientSecretExpiresAt > 0
       && entry.grant.clientSecretExpiresAt * 1000 <= Date.now();
-    if (entry.needsReauth || clientSecretExpired || entry.grant.accessTokenExpiresAt <= Date.now()) {
+    if (entry.needsReauth || clientSecretExpired) {
       return { ok: false, kind: 'auth', serverKey: record.serverKey, serverName: record.serverName, message: 'OAuth 授权已过期或刷新失败，请重新授权' };
     }
+    if (entry.grant.accessTokenExpiresAt <= Date.now()) {
+      return {
+        ok: false,
+        kind: 'refresh',
+        serverKey: record.serverKey,
+        serverName: record.serverName,
+        message: entry.refreshPromise
+          ? 'OAuth Access Token 已到期，正在自动刷新'
+          : `OAuth 刷新暂时失败，正在自动重试${entry.lastRefreshError ? `：${entry.lastRefreshError}` : ''}`,
+      };
+    }
     return null;
   }
 
@@ -444,6 +626,7 @@ export async function apply(ctx, config) {
     const pendingServers = results.filter((result) => result.ok && result.kind === 'managed').length;
     const failedServers = results.filter((result) => !result.ok).length;
     const authFailures = results.filter((result) => !result.ok && result.kind === 'auth').length;
+    const refreshFailures = results.filter((result) => !result.ok && result.kind === 'refresh').length;
     let connectionState = 'configured';
     if (records.length === 0) connectionState = 'disconnected';
     else if (enabledRecords.length === 0) connectionState = 'disabled';
@@ -451,10 +634,11 @@ export async function apply(ctx, config) {
     else if (availableServers > 0 && (failedServers > 0 || pendingServers > 0)) connectionState = 'degraded';
     else if (pendingServers > 0 && failedServers === 0) connectionState = 'configured';
     else if (authFailures > 0) connectionState = 'reauth';
+    else if (refreshFailures > 0) connectionState = 'recovering';
     else if (failedServers > 0) connectionState = 'unavailable';
     const labels = {
       disconnected: '未连接', configured: '已配置', disabled: '已停用', healthy: '已连接',
-      degraded: '部分异常', reauth: '需重新授权', unavailable: '连接异常',
+      degraded: '部分异常', reauth: '需重新授权', recovering: '自动重试中', unavailable: '连接异常',
     };
     return {
       connectorId,
@@ -519,6 +703,156 @@ export async function apply(ctx, config) {
     return env;
   }
 
+  /* ───────────────────────── OAuth Grant 共享 ───────────────────────── */
+
+  function canonicalIssuer(value) {
+    try {
+      const url = new URL(value);
+      return `${url.origin}${url.pathname.replace(/\/+$/, '')}`;
+    } catch {
+      return String(value ?? '').replace(/\/+$/, '');
+    }
+  }
+
+  function oauthResourceOrigins(connector) {
+    return [...new Set((connector.servers ?? []).map((server) => {
+      try { return new URL(server.url).origin; } catch { return ''; }
+    }).filter(Boolean))].sort();
+  }
+
+  function oauthSharingConnectors(connector) {
+    if (connector.auth?.grantSharing !== 'issuer' || !connector.auth.issuer) return [connector];
+    const issuer = canonicalIssuer(connector.auth.issuer);
+    const resourceOrigins = new Set(oauthResourceOrigins(connector));
+    const matches = state.merged.filter((candidate) => (
+      candidate.published !== false
+      && candidate.auth?.mode === 'oauth2-pkce'
+      && candidate.auth.grantSharing === 'issuer'
+      && canonicalIssuer(candidate.auth.issuer) === issuer
+      && candidate.auth.scope === connector.auth.scope
+      && candidate.auth.tokenEndpointAuthMethod === connector.auth.tokenEndpointAuthMethod
+      // 防止同 issuer 的第三方描述把共享 Bearer Token 聚合到其他资源域名。
+      && oauthResourceOrigins(candidate).every((origin) => resourceOrigins.has(origin))
+    ));
+    // 授权请求的 resource 必须优先使用用户点击的卡片；其余同组 Server 只用于识别共享范围。
+    return [connector, ...matches.filter((candidate) => candidate.id !== connector.id)];
+  }
+
+  function oauthSharingKey(connector) {
+    if (connector.auth?.grantSharing !== 'issuer' || !connector.auth.issuer) return `connector:${connector.id}`;
+    return `issuer:${config.account}:${canonicalIssuer(connector.auth.issuer)}:${connector.auth.scope}:${connector.auth.tokenEndpointAuthMethod}:${oauthResourceOrigins(connector).join(',')}`;
+  }
+
+  function oauthAuthorizationDescriptor(connector, sharingConnectors) {
+    if (sharingConnectors.length === 1) return connector;
+    const seen = new Set();
+    const servers = [];
+    for (const candidate of sharingConnectors) {
+      for (const server of candidate.servers) {
+        if (seen.has(server.url)) continue;
+        seen.add(server.url);
+        servers.push({ ...server, serverKey: `${candidate.id}:${server.serverKey}` });
+      }
+    }
+    return { ...connector, servers };
+  }
+
+  function oauthRecordsFor(connectors, authorizedResources, grantKey) {
+    const granted = new Set(authorizedResources);
+    const now = Date.now();
+    const records = [];
+    for (const connector of connectors) {
+      for (const server of connector.servers.filter((candidate) => granted.has(candidate.url))) {
+        records.push({
+          key: `${connector.id}-${server.serverKey}`,
+          connectorId: connector.id,
+          kind: 'oauth',
+          name: connector.servers.length > 1 ? `${connector.name}·${server.serverKey}` : connector.name,
+          serverKey: server.serverKey,
+          transport: server.transport,
+          url: server.url,
+          serverName: server.serverName,
+          headers: server.headers,
+          auth: { mode: 'oauth', grantKey },
+          enabled: true,
+          createdAt: now,
+          updatedAt: now,
+        });
+      }
+    }
+    return records;
+  }
+
+  function ensureRequestedConnectorsAuthorized(requestedIds, records) {
+    const connectedIds = new Set(records.map((record) => record.connectorId));
+    const missing = [...requestedIds].filter((id) => !connectedIds.has(id));
+    if (missing.length === 0) return;
+    throw new Error(`本次授权未包含连接器所需的 MCP 资源：${missing.join(', ')}`);
+  }
+
+  async function findReusableSharedGrant(connector) {
+    if (connector.auth?.grantSharing !== 'issuer' || !connector.auth.issuer) return null;
+    const issuer = canonicalIssuer(connector.auth.issuer);
+    for (const [grantKey, entry] of state.grants) {
+      const grant = entry.grant;
+      if (entry.needsReauth
+          || grant.account !== config.account
+          || grant.scope !== connector.auth.scope
+          || (grant.tokenEndpointAuthMethod ?? 'none') !== connector.auth.tokenEndpointAuthMethod
+          || canonicalIssuer(grant.issuer) !== issuer) continue;
+
+      if (grant.accessTokenExpiresAt <= Date.now()) {
+        try {
+          await refreshGrantWithRecovery(grantKey, 'shared-connect');
+        } catch (error) {
+          if (error.refreshFailure?.kind === 'transient') {
+            return { temporaryFailure: error.refreshFailure };
+          }
+          continue;
+        }
+      }
+      if (connector.servers.some((server) => entry.grant.authorizedResources.includes(server.url))) {
+        return { grantKey, entry };
+      }
+    }
+    return null;
+  }
+
+  async function attachConnectorsToGrant(grantKey, entry, connectors, requestedIds) {
+    const usableConnectors = connectors.filter((connector) => {
+      const conflict = legacyConflictForConnector(connector);
+      if (!conflict) return true;
+      warnLegacyConflict(conflict);
+      return false;
+    });
+    const records = oauthRecordsFor(usableConnectors, entry.grant.authorizedResources, grantKey);
+    ensureRequestedConnectorsAuthorized(requestedIds, records);
+    const connectedConnectorIds = [...new Set(records.map((record) => record.connectorId))];
+    const previous = entry.grant;
+    const next = {
+      ...previous,
+      connectorIds: [...new Set([...(previous.connectorIds ?? []), ...connectedConnectorIds])],
+      updatedAt: Date.now(),
+    };
+    entry.grant = next;
+    if (config.persistSecrets) await grantStore.put(next);
+    try {
+      const committed = await commitConnectionRecords(records);
+      for (const connector of usableConnectors) {
+        const own = committed.filter((record) => record.connectorId === connector.id);
+        if (own.length > 0) cacheHealth(connector.id, own, readinessResults(own));
+      }
+      scheduleRefresh(grantKey);
+      return committed;
+    } catch (error) {
+      entry.grant = previous;
+      if (config.persistSecrets) await grantStore.put(previous).catch((rollbackError) => {
+        logger.error(`shared grant rollback ${grantKey} failed: ${rollbackError.message}`);
+      });
+      throw error;
+    }
+  }
+
   /* ───────────────────────── api 门面 ───────────────────────── */
 
   const api = {
@@ -578,18 +912,67 @@ export async function apply(ctx, config) {
       if (!connector) return { ok: false, message: `连接器 "${connectorId}" 不存在（可先 mcp_connector_refresh_catalog 或 mcp_connector_catalog 查看）` };
 
       if (connector.auth.mode === 'oauth2-pkce') {
-        const inFlight = state.oauthConnects.get(connector.id);
-        if (inFlight) return inFlight;
+        const conflict = legacyConflictForConnector(connector);
+        if (conflict) {
+          warnLegacyConflict(conflict);
+          return { ok: false, message: conflict.message, detail: { kind: 'plugin-conflict', pluginId: conflict.pluginId, serverName: conflict.serverName } };
+        }
+
+        const sharingKey = oauthSharingKey(connector);
+        const inFlight = state.oauthConnects.get(sharingKey);
+        if (inFlight) {
+          inFlight.requestedConnectorIds.add(connector.id);
+          return inFlight.promise;
+        }
+        const requestedConnectorIds = new Set([connector.id]);
         const promise = (async () => {
           try {
+            const sharingConnectors = oauthSharingConnectors(connector);
+            const reusable = await findReusableSharedGrant(connector);
+            if (reusable?.temporaryFailure) {
+              return {
+                ok: false,
+                message: `OAuth 授权刷新暂时失败（${reusable.temporaryFailure.code}），插件将自动重试，无需重新授权`,
+                detail: { kind: 'refresh-retry', retrying: true },
+              };
+            }
+            if (reusable?.entry) {
+              const requestedConnectors = sharingConnectors.filter((item) => requestedConnectorIds.has(item.id));
+              const committed = await attachConnectorsToGrant(
+                reusable.grantKey,
+                reusable.entry,
+                requestedConnectors,
+                requestedConnectorIds,
+              );
+              const created = committed.map((record) => record.key);
+              return {
+                ok: true,
+                message: `已复用同账号 OAuth 授权连接 ${requestedConnectors.length} 个连接器（${created.length} 个 MCP server），无需再次授权`,
+                detail: { keys: created, grantKey: reusable.grantKey, reusedGrant: true, retiredGrantCount: 0 },
+              };
+            }
+
+            const sharingConnectorIds = new Set(sharingConnectors.map((item) => item.id));
             const previousGrantKeys = new Set(
               [...state.grants]
-                .filter(([, entry]) => entry.grant.connectorIds?.includes(connector.id))
+                .filter(([, entry]) => entry.grant.connectorIds?.some((id) => sharingConnectorIds.has(id)))
                 .map(([key]) => key),
             );
-            const authz = await oauthAuthorize({ connector, config, logger, signal });
+            const authorizationConnector = oauthAuthorizationDescriptor(connector, sharingConnectors);
+            const authz = await oauthAuthorize({ connector: authorizationConnector, config, logger, signal });
             const grantKey = grantStore.keyFor(config.account, authz.issuer, authz.clientId, authz.scope);
             const entryResource = authz.entryResource;
+            const authorizedResources = authz.grantedResources?.length ? authz.grantedResources : [entryResource];
+            const alreadyConnectedIds = new Set(
+              [...state.connections.values()]
+                .filter((record) => sharingConnectorIds.has(record.connectorId))
+                .map((record) => record.connectorId),
+            );
+            const targetIds = new Set([...alreadyConnectedIds, ...requestedConnectorIds]);
+            const targetConnectors = sharingConnectors.filter((item) => targetIds.has(item.id));
+            const previewRecords = oauthRecordsFor(targetConnectors, authorizedResources, grantKey);
+            ensureRequestedConnectorsAuthorized(requestedConnectorIds, previewRecords);
+            const grantedConnectorIds = [...new Set(previewRecords.map((record) => record.connectorId))];
             const grant = {
               key: grantKey,
               issuer: authz.issuer,
@@ -601,52 +984,27 @@ export async function apply(ctx, config) {
               scope: authz.scope,
               account: config.account,
               accessToken: authz.token.accessToken,
-              accessTokenExpiresAt: Date.now() + authz.token.expiresIn * 1000 - config.refreshSkewMs,
+              accessTokenExpiresAt: Date.now() + authz.token.expiresIn * 1000,
               refreshToken: authz.token.refreshToken ?? '',
-              authorizedResources: connector.servers
-                .filter((s) => authz.grantedKeys.includes(s.serverKey))
-                .map((s) => s.url).length
-                ? connector.servers.filter((s) => authz.grantedKeys.includes(s.serverKey)).map((s) => s.url)
-                : [entryResource],
-              connectorIds: [connector.id],
+              authorizedResources,
+              connectorIds: grantedConnectorIds,
               updatedAt: Date.now(),
             };
-            state.grants.set(grantKey, { grant, timer: undefined, refreshPromise: null, needsReauth: false });
+            const runtime = grantRuntime(grant);
+            state.grants.set(grantKey, runtime);
             if (config.persistSecrets) await grantStore.put(grant);
-
-            const records = [];
-            for (const sk of authz.grantedKeys) {
-              const server = connector.servers.find((s) => s.serverKey === sk);
-              if (!server) continue;
-              const record = {
-                key: `${connector.id}-${sk}`,
-                connectorId: connector.id,
-                kind: 'oauth',
-                name: connector.servers.length > 1 ? `${connector.name}·${sk}` : connector.name,
-                serverKey: sk,
-                transport: server.transport,
-                url: server.url,
-                serverName: server.serverName,
-                headers: server.headers,
-                auth: { mode: 'oauth', grantKey },
-                enabled: true,
-                createdAt: Date.now(),
-                updatedAt: Date.now(),
-              };
-              records.push(record);
-            }
-            const committed = await commitConnectionRecords(records);
+            const committed = await attachConnectorsToGrant(grantKey, runtime, targetConnectors, requestedConnectorIds);
             const created = committed.map((record) => record.key);
-            cacheHealth(connector.id, committed, readinessResults(committed));
-            scheduleRefresh(grantKey);
             let retiredGrantCount = 0;
             for (const previousKey of previousGrantKeys) {
               if (previousKey !== grantKey && await retireGrantIfUnused(previousKey, { revoke: true })) retiredGrantCount += 1;
             }
             return {
               ok: true,
-              message: `已连接 "${connector.name}"（${created.length} 个 MCP server），共 ${created.length} 条`,
-              detail: { keys: created, grantKey, retiredGrantCount },
+              message: sharingConnectors.length > 1
+                ? `OAuth 授权成功；已为同一账号保存共享授权并连接 ${targetConnectors.length} 个连接器（${created.length} 个 MCP server）`
+                : `已连接 "${connector.name}"（${created.length} 个 MCP server），共 ${created.length} 条`,
+              detail: { keys: created, grantKey, sharedGrant: sharingConnectors.length > 1, retiredGrantCount },
             };
           } catch (error) {
             logger.error(`oauth connect failed: ${error.message}`);
@@ -656,11 +1014,11 @@ export async function apply(ctx, config) {
               : { ok: false, message: `连接失败: ${error.message}` };
           }
         })();
-        state.oauthConnects.set(connector.id, promise);
+        state.oauthConnects.set(sharingKey, { promise, requestedConnectorIds });
         try {
           return await promise;
         } finally {
-          if (state.oauthConnects.get(connector.id) === promise) state.oauthConnects.delete(connector.id);
+          if (state.oauthConnects.get(sharingKey)?.promise === promise) state.oauthConnects.delete(sharingKey);
         }
       }
 
@@ -843,6 +1201,9 @@ export async function apply(ctx, config) {
                 grantKey: record.auth.grantKey,
                 accessTokenExpiresAt: g.grant.accessTokenExpiresAt,
                 needsReauth: !!g.needsReauth,
+                refreshFailureKind: g.refreshFailureKind,
+                lastRefreshError: g.lastRefreshError,
+                refreshRetryAt: g.refreshRetryAt,
               }
             : { grantKey: record.auth.grantKey, missing: true };
         }
@@ -924,7 +1285,7 @@ export async function apply(ctx, config) {
         summaries.push(cacheHealth(id, records, [...immediateResults, ...checkedResults]));
       }
       const healthy = summaries.filter((item) => item.connectionState === 'healthy').length;
-      const attention = summaries.filter((item) => ['reauth', 'degraded', 'unavailable'].includes(item.connectionState)).length;
+      const attention = summaries.filter((item) => ['reauth', 'recovering', 'degraded', 'unavailable'].includes(item.connectionState)).length;
       return {
         ok: true,
         message: targetIds.length === 0
@@ -957,24 +1318,34 @@ export async function apply(ctx, config) {
         if (plan.summary.alreadyMigrated) { skipped.push(`${plan.summary.connectorName}(已迁移)`); continue; }
         const grantKey = grantStore.keyFor(config.account, plan.candidate.grant.issuer, plan.candidate.grant.clientId, plan.candidate.grant.scope);
         const grant = toConnectorGrant(plan.candidate, { key: grantKey, account: config.account, connectorIds: [plan.connector.id] });
-        state.grants.set(grantKey, { grant, timer: undefined, refreshPromise: null, needsReauth: false });
+        state.grants.set(grantKey, grantRuntime(grant));
         if (config.persistSecrets) await grantStore.put(grant);
 
         let enabled = true;
+        let provisionNow = true;
         let lastError;
+        const legacyConflict = legacyConflictForConnector(plan.connector);
+        if (legacyConflict) {
+          warnLegacyConflict(legacyConflict);
+          provisionNow = false;
+          lastError = `${legacyConflict.message}；授权已复制，重启后将由 MCP连接器恢复`;
+        }
         if (grant.accessTokenExpiresAt <= Date.now()) {
-          try { await refreshGrant(grantKey); }
+          try { await refreshGrantWithRecovery(grantKey, 'legacy-migration'); }
           catch (error) {
-            enabled = false;
-            lastError = `旧授权已过期且刷新失败，请重新连接：${error instanceof Error ? error.message : String(error)}`;
-            state.grants.get(grantKey).needsReauth = true;
+            const permanent = error.refreshFailure?.permanent === true;
+            enabled = !permanent;
+            provisionNow = false;
+            lastError = permanent
+              ? `旧授权已失效，请重新连接：${error.refreshFailure?.message ?? error.message}`
+              : `旧授权刷新暂时失败，正在自动重试：${error.refreshFailure?.message ?? error.message}`;
           }
         } else {
           scheduleRefresh(grantKey);
         }
         const records = toConnectionRecords(plan, grantKey, { enabled, lastError });
         for (const record of records) {
-          if (enabled) await upsertRecord(record);
+          if (enabled && provisionNow) await upsertRecord(record);
           else await persistRecord(record);
         }
         migrated.push({ connectorId: plan.connector.id, keys: records.map((record) => record.key), enabled });
@@ -1207,6 +1578,7 @@ export async function apply(ctx, config) {
   /* ───────────────────────── 启动恢复 ───────────────────────── */
 
   await loadCatalog();
+  detectLegacyPluginConflicts();
 
   for (const [key, raw] of await connectionStore.entries().catch(() => [])) {
     try {
@@ -1218,7 +1590,7 @@ export async function apply(ctx, config) {
   }
   for (const [key, raw] of await grantStore.entries().catch(() => [])) {
     try {
-      state.grants.set(key, { grant: raw, timer: undefined, refreshPromise: null, needsReauth: false });
+      state.grants.set(key, grantRuntime(raw));
     } catch (error) {
       logger.warn(`skip invalid stored grant "${key}": ${error.message}`);
     }
@@ -1230,16 +1602,19 @@ export async function apply(ctx, config) {
   for (const [grantKey, g] of state.grants) {
     if (g.grant.accessTokenExpiresAt <= Date.now()) {
       try {
-        await refreshGrant(grantKey);
-      } catch {
-        g.needsReauth = true;
-      }
+        await refreshGrantWithRecovery(grantKey, 'startup');
+      } catch {}
     } else {
       scheduleRefresh(grantKey);
     }
   }
   for (const [key, record] of state.connections) {
     if (record.enabled !== false) {
+      const failure = grantFailure(record);
+      if (failure) {
+        logger.warn(`skip provision "${key}" at startup: ${failure.message}`);
+        continue;
+      }
       await provision(ctx, config, record, grantMap()).catch((error) => {
         logger.warn(`provision "${key}" failed: ${error.message}`);
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mcp-connector",
-  "version": "0.2.22",
+  "version": "0.2.23",
   "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",
@@ -33,7 +33,7 @@
   ],
   "scripts": {
     "test": "node --test",
-    "lint": "node --check lib/index.js && node --check lib/web.js && node --check lib/client.js && node --check lib/schema.js && node --check lib/catalog.js && node --check lib/prompts.js && node --check lib/probe.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/oauth.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/sync-registry-stats.mjs",
+    "lint": "node --check lib/index.js && node --check lib/web.js && node --check lib/client.js && node --check lib/schema.js && node --check lib/catalog.js && node --check lib/prompts.js && node --check lib/probe.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/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/sync-registry-stats.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

@@ -471,7 +471,7 @@
   const searchInput = $('#search');
   const LABELS = {
     details: '详情', connect: '连接', connected: '已连接', configured: '已配置', configure: '配置',
-    reauthorize: '需重新授权', connectionError: '连接异常', partialError: '部分异常', disabled: '已停用',
+    reauthorize: '需重新授权', recovering: '自动重试中', connectionError: '连接异常', partialError: '部分异常', disabled: '已停用',
     send: '发送', fillSend: '填写并发送', connectToUse: '连接后使用', try: '💬 去试试',
     connectTry: '🔗 连接后试用', configureConnect: '🔑 录入凭据并连接',
     reconfigureCredential: '🔑 重新配置凭据', loading: '加载中…',
@@ -857,6 +857,7 @@
       if (state === 'configured') return `<button class="btn ghost" type="button" onclick="event.stopPropagation();window.__mcp.showDetail('${id}')">${t('details')}</button><button class="btn ghost" disabled>${t('configured')}</button>`;
       if (state === 'disabled') return `<button class="btn ghost" type="button" onclick="event.stopPropagation();window.__mcp.showDetail('${id}')">${t('details')}</button><button class="btn ghost" disabled>${t('disabled')}</button>`;
       if (state === 'reauth') return `<button class="btn ghost" type="button" onclick="event.stopPropagation();window.__mcp.showDetail('${id}')">${t('details')}</button><button class="btn status-warning" type="button" onclick="event.stopPropagation();window.__mcp.showDetail('${id}')">${t('reauthorize')}</button>`;
+      if (state === 'recovering') return `<button class="btn ghost" type="button" onclick="event.stopPropagation();window.__mcp.showDetail('${id}')">${t('details')}</button><button class="btn status-warning" type="button" onclick="event.stopPropagation();window.__mcp.showDetail('${id}')">${t('recovering')}</button>`;
       if (state === 'degraded') return `<button class="btn ghost" type="button" onclick="event.stopPropagation();window.__mcp.showDetail('${id}')">${t('details')}</button><button class="btn status-warning" type="button" onclick="event.stopPropagation();window.__mcp.showDetail('${id}')">${t('partialError')}</button>`;
       if (state === 'unavailable') return `<button class="btn ghost" type="button" onclick="event.stopPropagation();window.__mcp.showDetail('${id}')">${t('details')}</button><button class="btn status-bad" type="button" onclick="event.stopPropagation();window.__mcp.showDetail('${id}')">${t('connectionError')}</button>`;
     }
@@ -886,8 +887,8 @@
   function rowHtml(r) {
     const key = esc(r.key);
     const authMode = r.authMode === 'oauth' ? '<span class="badge auth-oauth">OAuth</span>' : `<span class="badge">${esc(r.authMode || 'manual')}</span>`;
-    const healthLabels = { healthy: '已连接', configured: '已配置', reauth: '需重新授权', degraded: '部分异常', unavailable: '连接异常', disabled: '已停用' };
-    const healthClass = r.connectionState === 'healthy' ? 'pass' : ['reauth', 'degraded'].includes(r.connectionState) ? 'partial' : r.connectionState === 'unavailable' ? 'fail' : '';
+    const healthLabels = { healthy: '已连接', configured: '已配置', reauth: '需重新授权', recovering: '自动重试中', degraded: '部分异常', unavailable: '连接异常', disabled: '已停用' };
+    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 enabled = r.enabled !== false;
     return `<div class="row" data-key="${key}">
@@ -1208,7 +1209,7 @@
       if (!d) return;
       detailConnector = d;
       detailFailureState = d.connectionState || '';
-      detailNeedsReconfigure = ['reauth', 'unavailable'].includes(detailFailureState);
+      detailNeedsReconfigure = ['reauth', 'recovering', 'unavailable'].includes(detailFailureState);
       const loadId = ++detailLoadId;
       $('#detail-icon').innerHTML = isImageIcon(d.icon)
         ? `<img src="${esc(d.icon)}" alt="" onerror="this.parentElement.innerHTML='🔌';" />`