dsh-mcp-connector 0.2.43 → 0.2.44

package/CHANGELOG.md

@@ -4,6 +4,22 @@
 
 ## [Unreleased]
 
+## [0.2.44] - 2026-09-12
+
+### Added
+
+- 启动恢复及连接成功后后台发现工具，无需先打开详情；后台最多并行发现两个连接器，同一连接的并发 HTTP 发现合并。
+- 手动、JSON 导入和目录连接统一支持工具列表、搜索与详情，可按 connectionKey 精确定位；已安装页增加工具入口。
+- SSE 订阅期间每 30 秒重新发现以恢复断线状态；详情读取只读快照、重连后补同步，不形成事件刷新循环。
+
+### Fixed
+
+- 页面与 API 使用一致的搜索评分，精确工具名优先；后台发现中、读取失败与成功空列表分别展示。
+- Schema 清理区分参数名称与关键字，保留名为 default、const、examples 的合法参数；敏感默认值及示例仍不缓存。
+- 连接配置变更后失效旧缓存，忽略断开或重配期间返回的过期发现结果；查询继续遵守工作区可见范围。
+
+本次不新增目标工具执行、跨连接器搜索页面或凭据分享能力。
+
 ## [0.2.43] - 2026-09-12
 
 ### Added

package/README.en.md

@@ -178,7 +178,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.43`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.43](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.43).
+The current public version is [`dsh-mcp-connector@0.2.44`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.44](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.44).
 
 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

@@ -173,7 +173,7 @@ npm run dev:ui
 
 公共 Registry 每次合并后会生成 `catalog-stats.json`；本仓库的定时工作流每小时同步中英文介绍和统计快照。npm 页面中的静态正文随版本发布更新，上方动态统计徽标则直接读取 Registry，可在不发布新 npm 版本时保持实时数量一致。
 
-当前公开版本为 [`dsh-mcp-connector@0.2.43`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.43](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.43)。
+当前公开版本为 [`dsh-mcp-connector@0.2.44`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.44](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.44)。
 
 版本能力与变更记录见 [CHANGELOG.md](CHANGELOG.md)。
 Desktop 发版回归见 [docs/DESKTOP-E2E.md](docs/DESKTOP-E2E.md)。

package/lib/index.js

@@ -166,8 +166,10 @@ export async function apply(ctx, config) {
     warnedLegacyConflicts: new Set(),
     toolInventories: new Map(),  // serverName -> { observed, observedAt, tools: Set<rawName> }
     toolCatalogCache: new Map(), // connection key -> 最近成功、安全裁剪后的工具元数据
+    toolViews: new Map(), // connection key -> last discovery outcome (memory only)
   };
   const statusEvents = new StatusEventHub();
+  const toolRequests = new Map();
 
   const hostGovernance = createHostGovernanceController(ctx, {
     getRules: () => governancePolicies.snapshot().rules,
@@ -603,6 +605,13 @@ export async function apply(ctx, config) {
   async function persistRecord(record) {
     // 存储成功后才更新内存，避免落盘失败却在当前进程显示为“已安装”。
     if (config.persistSecrets) await connectionStore.put(record);
+    const previous = state.connections.get(record.key);
+    if (previous && (connectionToolCacheSignature(previous) !== connectionToolCacheSignature(record)
+        || JSON.stringify(previous.auth) !== JSON.stringify(record.auth)
+        || JSON.stringify(previous.headers) !== JSON.stringify(record.headers)
+        || JSON.stringify(previous.env) !== JSON.stringify(record.env))) {
+      await deleteLastSuccessfulTools(record.key);
+    }
     state.connections.set(record.key, record);
     clearRecordHealth(record);
   }
@@ -984,6 +993,8 @@ export async function apply(ctx, config) {
   }
 
   async function cacheLastSuccessfulTools(record, tools) {
+    // A request may finish after disconnect/reconfigure. Never resurrect old metadata.
+    if (state.connections.get(record.key) !== record || record.enabled === false) return null;
     const entry = createToolCatalogRecord(record, tools);
     state.toolCatalogCache.set(record.key, entry);
     if (config.persistSecrets) {
@@ -997,6 +1008,7 @@ export async function apply(ctx, config) {
   }
 
   async function deleteLastSuccessfulTools(key) {
+    state.toolViews.delete(key);
     state.toolCatalogCache.delete(key);
     if (config.persistSecrets) {
       await toolCatalogStore.delete(key).catch((error) => {
@@ -1014,9 +1026,10 @@ export async function apply(ctx, config) {
     return { entry, ...toolCatalogCacheView(entry) };
   }
 
-  function visibleToolCatalogEntries(workspaceId) {
+  function visibleToolCatalogEntries(workspaceId, connectionKey) {
     const entries = [];
     for (const record of state.connections.values()) {
+      if (connectionKey && record.key !== connectionKey) continue;
       if (record.enabled === false) continue;
       if (workspaceId && !connectionVisibleInWorkspace(connectionScopes.binding(record.key), workspaceId)) continue;
       const cached = cachedToolsForRecord(record);
@@ -2644,23 +2657,38 @@ export async function apply(ctx, config) {
     async toolSearch(input = {}) {
       try {
         const connectorId = String(input.connectorId ?? '').trim() || undefined;
-        if (connectorId && !state.merged.some((connector) => connector.id === connectorId)) {
+        if (connectorId && !state.merged.some((connector) => connector.id === connectorId)
+            && ![...state.connections.values()].some((record) => record.connectorId === connectorId
+              && record.enabled !== false && (!input.workspaceId || connectionVisibleInWorkspace(connectionScopes.binding(record.key), input.workspaceId)))) {
           return { ok: false, message: `连接器 "${connectorId}" 不存在` };
         }
-        const items = searchToolCatalog(visibleToolCatalogEntries(input.workspaceId), {
+        const items = searchToolCatalog(visibleToolCatalogEntries(input.workspaceId, input.connectionKey), {
           query: input.query,
           connectorId,
           limit: input.limit,
         });
         const staleCount = items.filter((item) => item.stale).length;
+        const visibleRecords = [...state.connections.values()].filter((record) => record.enabled !== false
+          && (!connectorId || record.connectorId === connectorId)
+          && (!input.connectionKey || record.key === input.connectionKey)
+          && (!input.workspaceId || connectionVisibleInWorkspace(connectionScopes.binding(record.key), input.workspaceId)));
+        const pendingServers = visibleRecords.filter((record) => !cachedToolsForRecord(record)
+          && state.toolViews.get(record.key)?.record !== record).length;
+        const failedServers = visibleRecords.filter((record) => {
+          const view = state.toolViews.get(record.key);
+          return view?.record === record && !view.server.ok;
+        }).length;
+        if (pendingServers > 0) scheduleDiscovery();
         return {
           ok: true,
-          message: `最后成功工具缓存中找到 ${items.length} 个匹配项${staleCount ? `，其中 ${staleCount} 个已超过 24 小时` : ''}`,
+          message: `最后成功工具缓存中找到 ${items.length} 个匹配项${staleCount ? `，其中 ${staleCount} 个已超过 24 小时` : ''}${pendingServers ? `；${pendingServers} 个服务正在后台发现` : ''}${failedServers ? `；${failedServers} 个服务最近读取失败` : ''}`,
           detail: {
             items,
             source: 'last-success-cache',
             discoveryOnly: true,
             credentialsStored: false,
+            pendingServers,
+            failedServers,
           },
         };
       } catch (error) {
@@ -2672,7 +2700,7 @@ export async function apply(ctx, config) {
       try {
         const connectorId = String(input.connectorId ?? '').trim() || undefined;
         const serverName = String(input.serverName ?? '').trim() || undefined;
-        const matches = findToolDetails(visibleToolCatalogEntries(input.workspaceId), {
+        const matches = findToolDetails(visibleToolCatalogEntries(input.workspaceId, input.connectionKey), {
           toolName: input.toolName,
           connectorId,
           serverName,
@@ -2709,15 +2737,40 @@ export async function apply(ctx, config) {
      * 从已连接的 MCP server 动态获取工具清单
      * 通过 MCP JSON-RPC 协议调用 tools/list 方法
      */
-    async toolsList(connectorId, workspaceId) {
+    async toolsList(connectorId, workspaceId, cachedOnly = false, connectionKey) {
       const connector = state.merged.find((d) => d.id === connectorId);
-      if (!connector) return { ok: false, message: `连接器 "${connectorId}" 不存在` };
 
       const records = [...state.connections.values()].filter((record) => (
         record.connectorId === connectorId
+        && (!connectionKey || record.key === connectionKey)
         && record.enabled !== false
         && (!workspaceId || connectionVisibleInWorkspace(connectionScopes.binding(record.key), workspaceId))
       ));
+      if (connectionKey && !records.length) return { ok: false, message: '连接不存在、已停用或当前工作区不可见' };
+      if (!connector && !records.length) return { ok: false, message: `连接器 "${connectorId}" 不存在或当前工作区不可见` };
+      if (cachedOnly && records.length) {
+        const servers = records.map((record) => {
+          const cached = cachedToolsForRecord(record);
+          const view = state.toolViews.get(record.key);
+          const current = view?.record === record ? view.server : null;
+          return {
+            serverKey: record.serverKey || record.name, serverName: record.serverName,
+            ok: current?.ok === true, cached: Boolean(cached),
+            unknown: !current || current.unknown === true,
+            pending: !current && !cached,
+            error: current?.error || (!cached && !current ? '正在后台发现工具，请稍候' : undefined),
+            policy: serverPolicy(record),
+            ...(cached ? { cacheObservedAt: cached.observedAt, cacheAgeMs: cached.cacheAgeMs, stale: cached.stale } : {}),
+            tools: (cached?.entry.tools || []).map((tool) => decorateToolPolicy(record, {
+              name: tool.name, title: tool.title || tool.name, description: tool.description || '',
+            })),
+          };
+        });
+        return { ok: servers.some((server) => server.ok), message: '最近工具发现状态', detail: {
+          connectorId, servers, totalTools: servers.reduce((sum, server) => sum + server.tools.length, 0),
+          source: 'last-success-cache',
+        } };
+      }
       if (!records.length) {
         const servers = (connector.toolsSnapshot ?? []).map((snapshot) => ({
           serverKey: snapshot.serverKey,
@@ -2740,7 +2793,7 @@ export async function apply(ctx, config) {
       for (const record of records) {
         if (record.transport === 'stdio') {
           const registered = registeredStdioTools(record);
-          const snapshot = (connector.toolsSnapshot ?? []).find((item) =>
+          const snapshot = (connector?.toolsSnapshot ?? []).find((item) =>
             item.serverKey === record.serverKey || item.serverName === record.serverName);
           const liveTools = registered.tools;
           let cached = cachedToolsForRecord(record);
@@ -2795,10 +2848,14 @@ export async function apply(ctx, config) {
           continue;
         }
         try {
-          const listed = await listMcpTools(record, {
-            timeoutMs: config.requestTimeoutMs,
-            grants: grantMap(),
-          });
+          let request = toolRequests.get(record);
+          if (!request) {
+            request = listMcpTools(record, { timeoutMs: config.requestTimeoutMs, grants: grantMap() });
+            toolRequests.set(record, request);
+          }
+          let listed;
+          try { listed = await request; }
+          finally { if (toolRequests.get(record) === request) toolRequests.delete(record); }
           state.toolInventories.set(record.serverName, {
             observed: true,
             observedAt: Date.now(),
@@ -2847,6 +2904,14 @@ export async function apply(ctx, config) {
         }
       }
 
+      if (records.some((record) => state.connections.get(record.key) !== record || record.enabled === false)) {
+        return { ok: false, message: '连接已变更，请重新读取工具' };
+      }
+      records.forEach((record, index) => {
+        if (state.connections.get(record.key) === record && record.enabled !== false) {
+          state.toolViews.set(record.key, { record, server: servers[index] });
+        }
+      });
       const totalTools = servers.reduce((sum, s) => sum + (s.tools?.length || 0), 0);
       const availableServers = servers.filter((server) => server.ok).length;
       const unknownServers = servers.filter((server) => server.unknown).length;
@@ -2982,7 +3047,53 @@ export async function apply(ctx, config) {
   hostGovernance.refresh();
   hostScopes.refresh();
 
-  const observableApi = observeStatusEvents(api, statusEvents);
+  // One background pass at a time; UI event refreshes read snapshots, never tools/list.
+  let discoveryDisposed = false;
+  let discoveryRunning = false;
+  let discoveryPending = false;
+  let discoveryTimer = null;
+  async function discoverTools() {
+    if (discoveryDisposed || discoveryRunning) return;
+    discoveryRunning = true;
+    discoveryPending = false;
+    try {
+      const ids = [...new Set([...state.connections.values()].filter((record) => record.enabled !== false).map((record) => record.connectorId))];
+      let cursor = 0;
+      await Promise.all(Array.from({ length: Math.min(2, ids.length) }, async () => {
+        while (cursor < ids.length && !discoveryDisposed) {
+          const id = ids[cursor++];
+          await api.toolsList(id).catch(() => {});
+        }
+      }));
+      if (!discoveryDisposed) statusEvents.publish('tools');
+    } finally {
+      discoveryRunning = false;
+      if (discoveryPending) scheduleDiscovery();
+    }
+  }
+  function scheduleDiscovery() {
+    if (discoveryDisposed) return;
+    discoveryPending = true;
+    if (discoveryRunning || discoveryTimer) return;
+    discoveryTimer = setTimeout(() => { discoveryTimer = null; void discoverTools(); }, 100);
+    discoveryTimer.unref?.();
+  }
+  const discoveryMutations = new Set(['connect', 'configure', 'importJson', 'installFromUrl', 'reconfigureConnection', 'setEnabled', 'restoreSnapshot', 'migrateLegacy']);
+  const discoveryApi = new Proxy(api, { get(target, property) {
+    const value = target[property];
+    if (!discoveryMutations.has(property)) return value;
+    return async (...args) => {
+      const result = await value.apply(target, args);
+      if (result?.ok) scheduleDiscovery();
+      return result;
+    };
+  } });
+  const observableApi = observeStatusEvents(discoveryApi, statusEvents);
+  scheduleDiscovery();
+  const discoveryInterval = setInterval(() => {
+    if (statusEvents.clients.size > 0) scheduleDiscovery();
+  }, 30_000);
+  discoveryInterval.unref?.();
   const disposeTools = registerTools(ctx, observableApi);
 
   /* ───────────────────────── web 半区（图形化市场）──────────────────────── */
@@ -3000,6 +3111,9 @@ export async function apply(ctx, config) {
   }
 
   ctx.effect(() => () => {
+    discoveryDisposed = true;
+    clearTimeout(discoveryTimer);
+    clearInterval(discoveryInterval);
     disposeTools();
     disposeWeb?.();
     hostGovernance.dispose();

package/lib/status-events.js

@@ -111,7 +111,7 @@ export function observeStatusEvents(api, eventHub, eventTypes = DEFAULT_EVENT_TY
         try {
           return await Reflect.apply(value, target, args);
         } finally {
-          eventHub.publish(eventType);
+          if (!(property === 'toolsList' && args[2] === true)) eventHub.publish(eventType);
         }
       };
     },

package/lib/tool-catalog-cache.js

@@ -23,7 +23,7 @@ function truncateUtf8(value, maxBytes) {
   return output;
 }
 
-function sanitizeSchemaValue(value, state, depth = 0) {
+function sanitizeSchemaValue(value, state, depth = 0, propertyMap = false) {
   if (state.nodes >= 2_048 || depth > 10) {
     state.truncated = true;
     return undefined;
@@ -47,12 +47,13 @@ function sanitizeSchemaValue(value, state, depth = 0) {
   const entries = Object.entries(value);
   if (entries.length > 128) state.truncated = true;
   for (const [rawKey, rawValue] of entries.slice(0, 128)) {
-    if (OMITTED_SCHEMA_KEYS.has(rawKey) || UNSAFE_KEYS.has(rawKey)) {
+    if ((!propertyMap && OMITTED_SCHEMA_KEYS.has(rawKey)) || UNSAFE_KEYS.has(rawKey)) {
       if (OMITTED_SCHEMA_KEYS.has(rawKey)) state.truncated = true;
       continue;
     }
     const key = truncateUtf8(rawKey, 256);
-    const child = sanitizeSchemaValue(rawValue, state, depth + 1);
+    const child = sanitizeSchemaValue(rawValue, state, depth + 1,
+      !propertyMap && ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas'].includes(rawKey));
     if (key && child !== undefined) output[key] = child;
   }
   return output;

package/lib/tools.js

@@ -607,6 +607,7 @@ export function registerTools(ctx, api) {
       properties: {
         connectorId: { type: 'string', description: '连接器 id（来自 mcp_connector_catalog）' },
         workspaceId: { type: 'string', description: '可选；只加载在该 Workspace 可见的已连接 Server' },
+        connectionKey: { type: 'string', description: '可选；来自 status 的连接 key，限定手动、JSON 或目录安装的单条连接' },
       },
       required: ['connectorId'],
       additionalProperties: false,
@@ -614,7 +615,7 @@ export function registerTools(ctx, api) {
     output: toolsListOutput,
     timeoutMs: 30_000,
     async execute(args) {
-      return api.toolsList(args.connectorId, args.workspaceId);
+      return api.toolsList(args.connectorId, args.workspaceId, false, args.connectionKey);
     },
   });
 
@@ -640,6 +641,7 @@ export function registerTools(ctx, api) {
       type: 'object',
       properties: {
         query: { type: 'string', description: '工具名称、标题或描述关键词' },
+        connectionKey: { type: 'string', description: '可选；限定单条连接 key' },
         connectorId: { type: 'string', description: '可选；限定连接器 id' },
         workspaceId: { type: 'string', description: '可选；仅搜索该 Workspace 可见的连接' },
         limit: { type: 'number', minimum: 1, maximum: 100, description: '最多返回数量，默认 20' },
@@ -672,6 +674,7 @@ export function registerTools(ctx, api) {
       type: 'object',
       properties: {
         toolName: { type: 'string', description: '精确工具名（来自 mcp_connector_tool_search）' },
+        connectionKey: { type: 'string', description: '可选；限定单条连接 key' },
         connectorId: { type: 'string', description: '可选；用于消除同名歧义' },
         serverName: { type: 'string', description: '可选；用于消除同名歧义' },
         workspaceId: { type: 'string', description: '可选；仅查看该 Workspace 可见的连接' },

package/lib/web.js

@@ -48,7 +48,7 @@ const API_WHITELIST = new Map([
   ['disconnect', (api, p) => api.disconnect(p?.key)],
   ['setEnabled', (api, p) => api.setEnabled(p?.key, p?.enabled !== false)],
   ['refreshCatalog', (api) => api.refreshCatalog()],
-  ['toolsList', (api, p) => api.toolsList(p?.connectorId, p?.workspaceId)],
+  ['toolsList', (api, p) => api.toolsList(p?.connectorId, p?.workspaceId, p?.cachedOnly === true, p?.connectionKey)],
   ['toolSearch', (api, p) => api.toolSearch(p ?? {})],
   ['toolDetail', (api, p) => api.toolDetail(p ?? {})],
 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mcp-connector",
-  "version": "0.2.43",
+  "version": "0.2.44",
   "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

@@ -782,7 +782,7 @@
   }
 
   function policySelect(scope, current, serverName = '', toolName = '', publicName = '', label = '') {
-    if (!detailConnector?.connected?.length) return '';
+    if (!detailConnector?.connected?.length || detailConnector.connectionKey) return '';
     return `<select class="policy-select" data-policy-scope="${esc(scope)}" data-current-effect="${esc(current || 'inherit')}" data-server-name="${esc(serverName)}" data-tool-name="${esc(toolName)}" data-public-name="${esc(publicName)}" aria-label="${esc(label || `${scope} 策略`)}">${policyOptions(current)}</select>`;
   }
 
@@ -799,7 +799,7 @@
 
   function syncGovernanceBar() {
     const bar = $('#governance-bar');
-    const connected = detailConnector?.connected?.length > 0;
+    const connected = detailConnector?.connected?.length > 0 && !detailConnector.connectionKey;
     bar.hidden = !connected;
     if (!connected) return;
     const connectionEffect = detailGovernance?.connectionPolicy || 'inherit';
@@ -861,8 +861,34 @@
     if (result.ok && detailConnector) await window.__mcp.showDetail(detailConnector.id);
   }
 
+  function normalizeToolSearchText(value) {
+    return String(value ?? '').normalize('NFKC')
+      .replace(/([\p{Script=Han}])([A-Za-z0-9])/gu, '$1 $2')
+      .replace(/([A-Za-z0-9])([\p{Script=Han}])/gu, '$1 $2')
+      .toLocaleLowerCase('zh-CN').replace(/[^\p{Letter}\p{Number}]+/gu, ' ').trim().replace(/\s+/g, ' ');
+  }
+
+  function toolSearchScore(tool, query) {
+    const terms = query.split(' ').filter(Boolean);
+    const fields = [tool.name, tool.title, tool.description].map(normalizeToolSearchText);
+    const compactQuery = query.replace(/ /g, '');
+    const compactFields = fields.map((field) => field.replace(/ /g, ''));
+    const fieldIndex = fields.findIndex((field, index) => (
+      terms.every((term) => field.includes(term)) || compactFields[index].includes(compactQuery)
+    ));
+    if (fieldIndex < 0) return -1;
+    const field = fields[fieldIndex];
+    const compact = compactFields[fieldIndex];
+    let score = fieldIndex === 0 ? 300 : fieldIndex === 1 ? 180 : 80;
+    if (field === query || compact === compactQuery) score += 1_000;
+    else if (field.startsWith(query) || compact.startsWith(compactQuery)) score += 500;
+    else if (field.includes(query) || compact.includes(compactQuery)) score += 250;
+    score -= Math.min(field.length, 200) / 1_000;
+    return score;
+  }
+
   function renderTools() {
-    const query = $('#tools-search').value.trim().toLowerCase();
+    const query = normalizeToolSearchText($('#tools-search').value);
     if (detailToolServers.length === 0) {
       updateToolsSummary();
       $('#detail-tools').innerHTML = '<div class="tools-empty">暂无可用工具</div>';
@@ -871,17 +897,22 @@
     let matchedTools = 0;
     let renderedTools = 0;
     let remaining = toolRenderLimit;
-    const groups = detailToolServers.map((server) => {
+    const rankedServers = query ? [...detailToolServers].sort((a, b) =>
+      Math.max(-1, ...(b.tools || []).map((tool) => toolSearchScore(tool, query)))
+      - Math.max(-1, ...(a.tools || []).map((tool) => toolSearchScore(tool, query)))) : detailToolServers;
+    const groups = rankedServers.map((server) => {
       const label = server.serverName || server.serverKey || 'MCP Server';
       const serverSelect = policySelect('server', server.policy?.configuredEffect, server.serverName, '', '', `${label} Server 策略`);
       if (!server.ok && !server.cached) {
         if (query) return '';
-        return `<div class="tools-server"><div class="tools-server-header"><span class="tools-server-copy">${esc(label)} <span class="count">· 加载失败</span></span>${serverSelect}</div><div class="tools-error">${esc(server.error || '未知错误')}</div></div>`;
+        return `<div class="tools-server"><div class="tools-server-header"><span class="tools-server-copy">${esc(label)} <span class="count">· ${server.pending ? '正在发现' : '加载失败'}</span></span>${serverSelect}</div><div class="tools-error">${esc(server.error || '未知错误')}</div></div>`;
       }
       const matched = (server.tools || []).filter((tool) => {
         if (!query) return true;
-        return `${tool.name || ''}\n${tool.title || ''}\n${tool.description || ''}`.toLowerCase().includes(query);
-      }).sort((left, right) => Number(isDeprecatedTool(left)) - Number(isDeprecatedTool(right)));
+        return toolSearchScore(tool, query) >= 0;
+      }).sort((left, right) => query
+        ? toolSearchScore(right, query) - toolSearchScore(left, query) || left.name.localeCompare(right.name)
+        : Number(isDeprecatedTool(left)) - Number(isDeprecatedTool(right)));
       if (query && matched.length === 0) return '';
       matchedTools += matched.length;
       const tools = matched.slice(0, Math.max(0, remaining));
@@ -923,6 +954,7 @@
   async function openToolDetail(serverName, toolName) {
     if (!detailConnector || !toolName) return;
     const result = await call('toolDetail', {
+      connectionKey: detailConnector.connectionKey,
       connectorId: detailConnector.id,
       serverName,
       toolName,
@@ -1166,6 +1198,7 @@
       </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>` : ''}
+      ${enabled ? `<button class="btn ghost" type="button" onclick="window.__mcp.showConnectionTools('${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>`;
@@ -1708,8 +1741,17 @@
       showToast(result.message, result.ok);
       await loadInstalled();
     },
-    async showDetail(connectorId) {
-      const d = marketItems[connectorId];
+    async showConnectionTools(key) {
+      const record = installedItems.find((item) => item.key === key);
+      if (!record) return;
+      await window.__mcp.showDetail(record.connectorId, {
+        id: record.connectorId, connectionKey: key, name: record.name, icon: '🔌',
+        authMode: record.authMode, connected: [record], connectionState: record.connectionState,
+        description: '本机连接的工具发现与参数详情；不会执行工具。',
+      });
+    },
+    async showDetail(connectorId, connectionDescriptor) {
+      const d = connectionDescriptor || marketItems[connectorId];
       if (!d) return;
       detailConnector = d;
       const incomplete = d.connected?.length > 0 && d.connectionComplete === false;
@@ -1738,6 +1780,8 @@
       syncGovernanceBar();
       setDetailOpen(true);
       $('#detail-disconnect-btn').style.display = d.connected?.length > 0 ? 'block' : 'none';
+      if (d.connectionKey) $('#detail-disconnect-btn').style.display = 'none';
+      $('#detail-try-btn').style.display = d.connectionKey ? 'none' : '';
       const needsCredential = ['bearer', 'api-key'].includes(d.authMode);
       $('#detail-try-btn').textContent = detailNeedsReconfigure
         ? detailFailureState === 'incomplete' ? (d.authMode === 'oauth2-pkce' ? t('upgradeOauth') : t('completeSetup')) : d.authMode === 'oauth2-pkce' && detailFailureState === 'reauth' ? '🔐 重新授权' : needsCredential && detailFailureState === 'reauth' ? t('reconfigureCredential') : '🔄 重新检查'
@@ -1749,7 +1793,7 @@
         return;
       }
       const [toolsResult, governanceResult] = await Promise.all([
-        call('toolsList', { connectorId, ...workspaceParams() }),
+        call('toolsList', { connectorId, connectionKey: d.connectionKey, ...workspaceParams() }),
         call('governance', {}),
       ]);
       if (loadId !== detailLoadId || !$('#detail-overlay').classList.contains('active')) return;
@@ -1951,13 +1995,52 @@
   });
   let statusEventSource = null;
   let statusRefreshTimer = null;
+  let statusRefreshRunning = false;
+  let statusRefreshPending = false;
+
+  async function refreshOpenToolDetail() {
+    if (!detailConnector || !$('#detail-overlay').classList.contains('active')) return;
+    const id = detailLoadId;
+    const result = await call('toolsList', { connectorId: detailConnector.id, connectionKey: detailConnector.connectionKey, ...workspaceParams(), cachedOnly: true });
+    if (id !== detailLoadId || !$('#detail-overlay').classList.contains('active')) return;
+    if (!result.detail?.servers) {
+      detailToolServers = [];
+      renderTools();
+      $('#tools-summary').textContent = result.message || '连接当前不可用';
+      return;
+    }
+    if (result.detail?.servers) {
+      detailToolServers = result.detail.servers;
+      renderTools();
+      const pending = detailToolServers.some((server) => server.pending);
+      const unknown = detailToolServers.some((server) => server.unknown);
+      const available = detailToolServers.filter((server) => server.ok).length;
+      const label = pending ? '正在后台发现工具' : unknown && available === 0 ? '工具状态尚未确认'
+        : available === detailToolServers.length ? '已连接'
+        : available > 0 ? '部分服务可用' : '当前连接异常';
+      detailFailureState = pending ? 'unknown' : available > 0 ? 'healthy' : 'unavailable';
+      detailNeedsReconfigure = !pending && available === 0;
+      $('#detail-vendor').textContent = detailConnector.vendor ? `${detailConnector.vendor} · ${label}` : label;
+      $('#detail-try-btn').textContent = detailNeedsReconfigure ? '🔄 重新检查' : t('try');
+    }
+  }
 
   function scheduleStatusRefresh() {
     if (document.hidden) return;
+    statusRefreshPending = true;
+    if (statusRefreshRunning) return;
     clearTimeout(statusRefreshTimer);
-    statusRefreshTimer = setTimeout(() => {
-      if (view === 'market') loadMarket({ checkHealth: false, preserveScroll: true });
-      else loadInstalled();
+    statusRefreshTimer = setTimeout(async () => {
+      statusRefreshRunning = true;
+      statusRefreshPending = false;
+      try {
+        if (view === 'market') await loadMarket({ checkHealth: false, preserveScroll: true });
+        else await loadInstalled();
+        await refreshOpenToolDetail();
+      } finally {
+        statusRefreshRunning = false;
+        if (statusRefreshPending) scheduleStatusRefresh();
+      }
     }, 150);
   }
 
@@ -1965,6 +2048,7 @@
     if (typeof EventSource !== 'function' || statusEventSource) return;
     const source = new EventSource('/mcp-connector/events');
     statusEventSource = source;
+    source.addEventListener('ready', scheduleStatusRefresh);
     source.addEventListener('status', (event) => {
       try {
         const payload = JSON.parse(event.data);