dsh-model-doctor 0.3.0 → 0.4.1

package/README.md

@@ -30,13 +30,21 @@ DSH 桌面客户端插件：在对话输入区的**模型选择菜单**里，为
 
 ## 依赖与适配
 
-- 模型菜单本体由 **dsh-reasoning-effort** 插件渲染（`.re-model-*` 行结构）。本插件是
-  行内 DOM 增强：在既有行上追加自持元素并 `stopPropagation`，不替换任何 React 节点、
-  不抢 `conversation.input.model` 座位。禁用 dsh-reasoning-effort 后按钮不出现（安全无副作用）。
+- **不依赖任何菜单渲染插件**：官方原生模型菜单、`dsh-effort-slider`、`dsh-reasoning-effort`，
+  或将来任何第三方菜单，本插件都能工作。
+  - 通用路径：从宿主半取回权威模型目录（provider/model 名称），在弹层里按「文本命中已知
+    模型名」定位模型行，再向上取最近的可点击祖先作为行容器；
+  - 兼容路径：若检测到 `dsh-reasoning-effort` 的 `.re-model-menu` 结构，则改用其
+    section/group 精确分组匹配（更稳，优先使用）。
+- 只做行内 DOM 增强：在既有行上追加自持元素并 `stopPropagation`，不替换任何 React 节点、
+  不抢 `conversation.input.model` 座位，因此不会与滑块类插件冲突。
 - 宿主↔浏览器通道走 `ctx.connection.fetch.register` 注册到共享 `/api` 通道
   （客户端裸 `fetch('/api/model-doctor/...')`），这是桌面端实测可达的机制。
 - `package.json` 的 `dsh.client.immediately: true` 必须保留：客户端脚本包默认懒加载，
   没有它纯 DOM 增强插件永远不会被激活。
+- 遇到界面不显示时，客户端半会把 DOM 自检结果上报到
+  `%USERPROFILE%\.dsh\model-doctor-client-report.json`（记录命中的弹层根、行数、样本类名），
+  便于定位菜单结构变化。
 
 ## 安装
 
@@ -68,6 +76,8 @@ DSH 桌面客户端插件：在对话输入区的**模型选择菜单**里，为
 
 ## 版本
 
+- v0.4.0 — **解耦菜单渲染插件**：新增「已知模型名 + 可点击行」通用定位路径，官方原生菜单可用；
+  不再依赖也不冲突于 dsh-reasoning-effort / dsh-effort-slider；新增客户端 DOM 自检上报
 - v0.3.0 — 检测结果持久化（跨菜单开关与重启保留，只留最近一次）
 - v0.2.1 — 按钮放大到 27px
 - v0.2.0 — 修复结果回填映射（重扫重新入表 + 模型 id 兜底匹配）、按钮钉在选项右侧、

package/lib/client/index.js

@@ -1,16 +1,18 @@
 /**
  * dsh-model-doctor — 浏览器半（无框架，纯 DOM 增强）。
  *
- * 监听模型选择菜单（dsh-reasoning-effort 渲染的 .re-model-menu）的出现，
- * 在每个模型选项行末尾追加两枚小按钮：
- *   ⟳  连通检测 —— 经回环 RPC 让 Host 直连网关探测该模型（连通/欠费/限流/鉴权），
- *      结果以行内小徽章呈现（悬停看完整报错）；
- *   🗑  删除 —— 两段式确认后让 Host 从 llm-pi-ai 配置移除该模型（Host 自动备份
- *      配置文档），随后立即移除该行，菜单重开时即为新目录。
+ * 【解耦设计】本插件不依赖任何菜单渲染插件（dsh-reasoning-effort / dsh-effort-slider /
+ * 官方原生菜单都可以）：
+ *   1. 首选路径：从宿主半取回权威模型目录（provider/model 名称），
+ *      在文档里按「文本命中已知模型名」定位模型行，再向上找到可点击祖先作为行容器；
+ *   2. 兼容路径：若检测到 `.re-model-menu`（dsh-reasoning-effort 的菜单），
+ *      走其 section/group 结构做精确分组匹配（更稳，优先使用）。
+ * 两条路径都只做「行内追加自持元素」：不替换 React 节点、不抢座位、事件 stopPropagation。
  *
- * 菜单顶部追加「全部检测」按钮与供应商余额展示（siliconflow）。
- * 本半不替换任何 React 节点、不与 dsh-reasoning-effort 抢座位：全部增强都在
- * 既有行内追加自持元素，事件上 stopPropagation 阻止冒泡到选项本身。
+ * 每个模型行追加两枚按钮：
+ *   ⟳  连通检测 —— 让 Host 直连网关探测该模型（连通/欠费/限流/鉴权），结果行内徽章呈现；
+ *   🗑  删除 —— 两段式确认后让 Host 从 llm-pi-ai 配置移除该模型（Host 自动备份配置文档）。
+ * 菜单顶部追加「全部检测」按钮与账户余额展示。
  *
  * @module dsh-model-doctor/client
  */
@@ -22,13 +24,24 @@ window.__ModuleLoader__.load({
     const exports = module.exports
 
     const API_BASE = '/api/model-doctor'
+    /** 兼容路径：dsh-reasoning-effort 渲染的菜单。 */
     const MENU_SEL = '.re-model-menu'
     const PANE_SEL = '.re-model-pane'
     const ROW_SEL = '.re-model-option'
     const NAME_SEL = '.re-model-option-name'
     const TITLE_SEL = '.re-model-group-title'
+    /** 通用路径：各类弹层菜单可能的根容器（官方菜单 / 第三方滑块插件都在其中）。 */
+    const MENU_ROOT_SEL = [
+      '[role="menu"]',
+      '[role="listbox"]',
+      '[data-radix-popper-content-wrapper]',
+      '[role="dialog"]',
+      '[data-state="open"][aria-modal]',
+    ].join(',')
     const DIRECTORY_TTL_MS = 30000
     const DIRECTORY_RETRY_MS = 10000
+    /** 一个菜单里至少要有这么多个模型行，才认定它是模型菜单（防误伤其他弹层）。 */
+    const MIN_GENERIC_ROWS = 2
 
     /** 客户端半不需要上下文服务：宿主通道走 /api 裸 fetch。 */
     const inject = []
@@ -91,6 +104,7 @@ window.__ModuleLoader__.load({
         deleteModel: (provider, model) => call('deleteModel', { provider, model }),
         resultsLoad: () => call('resultsLoad'),
         resultsSave: (snapshot) => call('resultsSave', snapshot),
+        clientReport: (state) => call('clientReport', state),
       }
     }
 
@@ -121,6 +135,11 @@ window.__ModuleLoader__.load({
     const rowByKey = new Map()
     /** 模型 id -> 行元素（全表唯一时可用）：供应商 id 空间对不上时的兜底匹配。 */
     const rowByModel = new Map()
+    /** 行元素 -> 名字锚点（通用路径下用于把徽章插到模型名后面）。 */
+    let rowAnchor = new WeakMap()
+    /** 本次扫描的通用路径诊断信息（上报给宿主，便于远程定位 DOM 结构）。 */
+    let lastDiagnostics = null
+
     /** 本页会话内已删除的模型键，防目录未刷新时行又冒出来。 */
     const deletedKeys = new Set()
 
@@ -138,6 +157,7 @@ window.__ModuleLoader__.load({
           directoryAt = Date.now()
           directoryFailedAt = 0
           directoryError = ''
+          tokenIndexAt = 0
           scheduleEnhance()
         } else {
           directoryFailedAt = Date.now()
@@ -149,6 +169,203 @@ window.__ModuleLoader__.load({
       })
     }
 
+    /* ---------------------------------------------------------------- */
+    /* 通用行定位：不依赖任何菜单插件的类名                                */
+    /* ---------------------------------------------------------------- */
+
+    /** 归一化文本：折叠空白 + 小写，用于名字比对。 */
+    function normText(value) {
+      return String(value ?? '').replace(/\s+/gu, ' ').trim().toLowerCase()
+    }
+
+    /** 模型名/ID -> 候选条目索引；15 秒内复用。 */
+    let tokenIndex = null
+    let tokenIndexAt = 0
+    /** 预编译的 token 正则（先粗筛文本节点，避免对每个节点做全量比对）。 */
+    let tokenRegex = null
+    /** [token, entries] 按 token 长度降序：优先匹配更具体的名字。 */
+    let tokenPairs = []
+
+    function ensureTokenIndex() {
+      if (tokenIndex !== null && Date.now() - tokenIndexAt < 15000) return tokenIndex
+      const index = new Map()
+      for (const provider of directory?.providers ?? []) {
+        for (const model of provider.models) {
+          const tokens = new Set([normText(model.name), normText(model.id)])
+          for (const token of tokens) {
+            if (token.length < 2) continue
+            const list = index.get(token) ?? []
+            list.push({
+              providerId: provider.id,
+              providerName: provider.name,
+              modelId: model.id,
+              modelName: model.name,
+            })
+            index.set(token, list)
+          }
+        }
+      }
+      tokenIndex = index
+      tokenIndexAt = Date.now()
+      tokenPairs = Array.from(index.entries()).sort((a, b) => b[0].length - a[0].length)
+      tokenRegex = tokenPairs.length === 0
+        ? null
+        : new RegExp(tokenPairs.map(([token]) => token.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&')).join('|'), 'u')
+      return index
+    }
+
+    /** 元素是否像个可点击的「行」。 */
+    function looksLikeRow(el) {
+      const tag = el.tagName
+      if (tag === 'BUTTON' || tag === 'LI' || tag === 'A') return true
+      const role = el.getAttribute('role')
+      if (role !== null && /^(option|menuitem|menuitemradio|listitem|treeitem|button)$/u.test(role)) return true
+      if (el.hasAttribute('data-value') || el.hasAttribute('cmdk-item')) return true
+      if (el.hasAttribute('tabindex')) return true
+      try {
+        if (window.getComputedStyle(el).cursor === 'pointer') return true
+      } catch { /* 忽略计算样式失败 */ }
+      return false
+    }
+
+    /** 从文本节点往上找最近的可点击行容器。 */
+    function clickableRow(anchor, root) {
+      let el = anchor
+      let depth = 0
+      while (el !== null && el !== root && depth < 8) {
+        if (looksLikeRow(el)) return el
+        el = el.parentElement
+        depth += 1
+      }
+      return looksLikeRow(root) ? root : null
+    }
+
+    /** 候选条目里挑一个：多供应商同名时用上下文里的供应商名消歧。 */
+    function pickEntry(entries, row) {
+      if (entries.length === 1) return entries[0]
+      let context = normText(row.textContent)
+      let el = row.parentElement
+      let depth = 0
+      while (el !== null && depth < 3) {
+        context += ` ${normText(el.textContent).slice(0, 400)}`
+        el = el.parentElement
+        depth += 1
+      }
+      const matched = entries.filter(
+        (entry) => typeof entry.providerName === 'string'
+          && entry.providerName.length > 0
+          && context.includes(normText(entry.providerName)),
+      )
+      if (matched.length === 1) return matched[0]
+      return entries[0]
+    }
+
+    /**
+     * 全文档找出「命中了已知模型名」的最小行容器。
+     * 不再依赖任何菜单根选择器：先用预编译正则粗筛文本节点，再逐一确认 token 命中，
+     * 然后向上取最近的可点击祖先。
+     */
+    function minimalMatches(root) {
+      const index = ensureTokenIndex()
+      const found = new Map()
+      if (index.size === 0 || tokenRegex === null) return found
+      const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT)
+      let node = walker.nextNode()
+      while (node !== null) {
+        const raw = node.nodeValue
+        if (raw !== null && raw.length > 1 && raw.length <= 200) {
+          const text = normText(raw)
+          if (text.length >= 2 && tokenRegex.test(text)) {
+            const anchor = node.parentElement
+            if (anchor !== null) {
+              for (const [token, entries] of tokenPairs) {
+                if (token.length > text.length || !text.includes(token)) continue
+                const row = clickableRow(anchor, root)
+                if (row === null) continue
+                const current = found.get(row)
+                if (current === undefined || token.length > current.token.length) {
+                  found.set(row, { token, entries, anchor })
+                }
+              }
+            }
+          }
+        }
+        node = walker.nextNode()
+      }
+      // 排除「容器型行」：行文本里出现两个以上不同模型 → 它装的是列表，不是单行。
+      for (const [row] of Array.from(found.entries())) {
+        if (countDistinctModels(row, index) > 1) found.delete(row)
+      }
+      return found
+    }
+
+    /** 一个元素里出现了几个不同模型（>1 说明它是容器）。 */
+    function countDistinctModels(el, index) {
+      const text = normText(el.textContent)
+      const distinct = new Set()
+      for (const [token, entries] of index) {
+        if (!text.includes(token)) continue
+        for (const entry of entries) distinct.add(`${entry.providerId}::${entry.modelId}`)
+        if (distinct.size > 1) return distinct.size
+      }
+      return distinct.size
+    }
+
+    /** 容器是否像弹层（绝对定位或带菜单语义），用于排除正文里碰巧出现的模型名。 */
+    function isPopoverish(el) {
+      let node = el
+      let depth = 0
+      while (node !== null && node !== document.body && depth < 4) {
+        const role = typeof node.getAttribute === 'function' ? node.getAttribute('role') : null
+        if (typeof role === 'string' && /^(menu|listbox|dialog|alertdialog)$/u.test(role)) return true
+        try {
+          const position = window.getComputedStyle(node).position
+          if (position === 'absolute' || position === 'fixed') return true
+        } catch { /* 忽略计算样式失败 */ }
+        node = node.parentElement
+        depth += 1
+      }
+      return false
+    }
+
+    /** 把命中的行按容器聚类：同一父节点下 ≥2 行才算一个菜单。 */
+    function clusterRows(found) {
+      const byParent = new Map()
+      for (const [row, hit] of found.entries()) {
+        const parent = row.parentElement ?? document.body
+        const list = byParent.get(parent) ?? []
+        list.push({ row, ...hit })
+        byParent.set(parent, list)
+      }
+      const clusters = []
+      const orphans = []
+      for (const [parent, list] of byParent.entries()) {
+        if (list.length >= 2) clusters.push({ host: parent, rows: list })
+        else orphans.push(...list)
+      }
+      // 行被分组标题/包装层隔开时，退一级按祖父容器聚合
+      if (orphans.length >= 2) {
+        const byGrand = new Map()
+        for (const hit of orphans) {
+          const grand = hit.row.parentElement?.parentElement ?? document.body
+          const list = byGrand.get(grand) ?? []
+          list.push(hit)
+          byGrand.set(grand, list)
+        }
+        for (const [grand, list] of byGrand.entries()) {
+          if (list.length >= 2) clusters.push({ host: grand, rows: list })
+        }
+      }
+      return clusters.filter((cluster) => isPopoverish(cluster.host))
+    }
+
+    /** 根容器是否可见（不可见的弹层跳过，避免误伤收起的菜单）。 */
+    function isVisible(el) {
+      if (!el.isConnected) return false
+      if (el.getClientRects().length > 0) return true
+      return el.offsetParent !== null
+    }
+
     /* ---------------------------------------------------------------- */
     /* 结果快照：加载 / 保存 / 回填                                       */
     /* ---------------------------------------------------------------- */
@@ -300,13 +517,23 @@ window.__ModuleLoader__.load({
       button.addEventListener('keydown', (event) => event.stopPropagation())
     }
 
+    /** 行里作为「模型名」的锚点：通用路径记录文本节点父元素，兼容路径用名字元素。 */
+    function labelAnchor(row) {
+      const mapped = rowAnchor.get(row)
+      if (mapped !== undefined && mapped.isConnected) return mapped
+      return row.querySelector(NAME_SEL)
+    }
+
     /** 把结果徽章插到模型名后面（随文字行内排，不占右侧按钮的位置）。 */
     function paintChip(row, result) {
       row.querySelectorAll('.dmd-chip').forEach((chip) => chip.remove())
       const chip = chipOf(result)
-      const name = row.querySelector(NAME_SEL)
-      if (name !== null && name.parentNode !== null) name.parentNode.insertBefore(chip, name.nextSibling)
-      else row.appendChild(chip)
+      const anchor = labelAnchor(row)
+      if (anchor !== null && anchor !== undefined && anchor.parentNode !== null) {
+        anchor.parentNode.insertBefore(chip, anchor.nextSibling)
+      } else {
+        row.appendChild(chip)
+      }
       return chip
     }
 
@@ -368,8 +595,15 @@ window.__ModuleLoader__.load({
     /* 「全部检测」条                                                    */
     /* ---------------------------------------------------------------- */
 
-    function ensureAllBar(pane, hint) {
-      const existing = pane.querySelector('.dmd-allbar')
+    /**
+     * 在 host 里放一条「全部检测」。
+     * @param host 承载容器
+     * @param hint 初始状态文案
+     * @param before 插入到该子节点之前（省略则插到最前）
+     */
+    function ensureAllBar(host, hint, before = null) {
+      if (host === null || host === undefined) return
+      const existing = host.querySelector('.dmd-allbar')
       if (existing !== null) {
         if (hint) {
           const status = existing.querySelector('.dmd-status')
@@ -377,8 +611,6 @@ window.__ModuleLoader__.load({
         }
         return
       }
-      const firstSection = pane.querySelector('section')
-      if (firstSection === null) return
       const bar = document.createElement('div')
       bar.className = 'dmd-allbar'
       const button = document.createElement('button')
@@ -437,7 +669,8 @@ window.__ModuleLoader__.load({
       bar.appendChild(status)
       bar.appendChild(balance)
       if (hint) status.textContent = hint
-      firstSection.parentNode.insertBefore(bar, firstSection)
+      if (before !== null && before.parentNode === host) host.insertBefore(bar, before)
+      else host.insertBefore(bar, host.firstChild)
     }
 
     function providerLabel(providerId) {
@@ -446,25 +679,40 @@ window.__ModuleLoader__.load({
     }
 
     /* ---------------------------------------------------------------- */
-    /* 菜单增强主逻辑                                                    */
+    /* 诊断上报（写进宿主文件，便于远程定位 DOM 结构，不影响功能）          */
     /* ---------------------------------------------------------------- */
 
-    function enhance() {
-      if (disposed) return
-      const menu = document.querySelector(MENU_SEL)
-      if (menu === null) return
+    let reportSignature = ''
+    let reportAt = 0
 
-      if (directory === null || Date.now() - directoryAt >= DIRECTORY_TTL_MS) {
-        void fetchDirectory()
-      }
+    function describe(el) {
+      if (el === null || el === undefined) return null
+      const cls = typeof el.className === 'string' ? el.className.trim().slice(0, 80) : ''
+      const text = normText(el.textContent).slice(0, 50)
+      return { tag: el.tagName, role: el.getAttribute('role') ?? '', cls, text }
+    }
 
-      rowByKey.clear()
-      rowByModel.clear()
+    function reportDiagnostics(state) {
+      if (doctor === null) return
+      const signature = JSON.stringify(state)
+      if (signature === reportSignature) return
+      if (Date.now() - reportAt < 1200) return
+      reportSignature = signature
+      reportAt = Date.now()
+      void doctor.clientReport(state)
+    }
+
+    /* ---------------------------------------------------------------- */
+    /* 菜单增强主逻辑                                                    */
+    /* ---------------------------------------------------------------- */
+
+    /** 兼容路径：dsh-reasoning-effort 的 `.re-model-menu` 结构。 */
+    function enhanceLegacy(menu) {
+      let wired = 0
       const panes = menu.querySelectorAll(PANE_SEL)
       panes.forEach((pane) => {
         const sections = pane.querySelectorAll('section')
         if (sections.length === 0) return
-        let wired = 0
         sections.forEach((section) => {
           const title = section.querySelector(TITLE_SEL)?.textContent?.trim()
           if (title === undefined || title.length === 0) return
@@ -475,6 +723,7 @@ window.__ModuleLoader__.load({
               const model = group.models[index]
               const name = row.querySelector(NAME_SEL)?.textContent?.trim()
               if (name !== undefined && name !== model.name) return
+              rowAnchor.set(row, row.querySelector(NAME_SEL) ?? row)
               enhanceRow(row, group.id, model)
               wired += 1
             })
@@ -491,6 +740,7 @@ window.__ModuleLoader__.load({
               }
             }
             if (hits.length !== 1) return
+            rowAnchor.set(row, row.querySelector(NAME_SEL) ?? row)
             enhanceRow(row, hits[0].provider.id, hits[0].model)
             wired += 1
           })
@@ -503,9 +753,100 @@ window.__ModuleLoader__.load({
         } else if (wired === 0) {
           hint = '模型医生：未匹配到模型行（目录与菜单不一致）'
         }
-        ensureAllBar(pane, hint)
-        if (wired > 0) paintLastRun('上次结果：')
+        ensureAllBar(pane, hint, pane.querySelector('section'))
       })
+      return wired
+    }
+
+    /**
+     * 通用路径：任何菜单渲染器（官方原生 / dsh-effort-slider / 其他弹层）。
+     * 依据「已知模型名」在全文定位行，按容器聚类成菜单，再逐行增强。
+     */
+    function enhanceGeneric(legacyWired) {
+      const index = ensureTokenIndex()
+      const roots = Array.from(document.querySelectorAll(MENU_ROOT_SEL)).filter((root) => isVisible(root))
+      const hits = minimalMatches(document.body)
+      const clusters = clusterRows(hits)
+      let wired = 0
+      let registered = 0
+      let unmatched = 0
+      const clusterStats = []
+      for (const cluster of clusters) {
+        let newlyWired = 0
+        for (const hit of cluster.rows) {
+          const entry = pickEntry(hit.entries, hit.row)
+          if (entry === undefined) {
+            unmatched += 1
+            continue
+          }
+          const isNew = hit.row.querySelector('.dmd-actions') === null
+          rowAnchor.set(hit.row, hit.anchor)
+          enhanceRow(hit.row, entry.providerId, { id: entry.modelId, name: entry.modelName })
+          registered += 1
+          if (isNew) newlyWired += 1
+        }
+        clusterStats.push({
+          host: describe(cluster.host),
+          rows: cluster.rows.length,
+          wired: newlyWired,
+        })
+        if (cluster.rows.length >= MIN_GENERIC_ROWS) {
+          const first = cluster.rows[0]
+          let hint = ''
+          if (directory === null) {
+            hint = directoryFailedAt !== 0
+              ? `模型医生：目录获取失败 · ${directoryError || '与宿主半通信异常'}`
+              : '模型医生：目录获取中…'
+          } else if (newlyWired === 0 && first.row.querySelector('.dmd-actions') === null) {
+            hint = '模型医生：模型行未匹配上目录'
+          }
+          const barHost = first.row.parentElement ?? cluster.host
+          ensureAllBar(barHost, hint, first.row)
+        }
+      }
+      lastDiagnostics = {
+        at: Date.now(),
+        mode: legacyWired > 0 ? 'legacy+generic' : 'generic',
+        href: window.location.href.slice(0, 120),
+        tokens: index.size,
+        providerCount: directory?.providers?.length ?? 0,
+        modelCount: (directory?.providers ?? []).reduce((sum, p) => sum + p.models.length, 0),
+        directoryError,
+        legacyWired,
+        genericWired: wired,
+        registered,
+        unmatched,
+        hitCount: hits.size,
+        visibleRoots: roots.length,
+        roots: clusterStats.slice(0, 8),
+        samples: roots.slice(0, 5).map(describe),
+        barCount: document.querySelectorAll('.dmd-allbar').length,
+        actionCount: document.querySelectorAll('.dmd-actions').length,
+      }
+      return registered > 0 ? Math.max(1, wired) : 0
+    }
+
+    function enhance() {
+      if (disposed) return
+      if (directory === null || Date.now() - directoryAt >= DIRECTORY_TTL_MS) {
+        void fetchDirectory()
+      }
+      rowByKey.clear()
+      rowByModel.clear()
+      rowAnchor = new WeakMap()
+
+      const menu = document.querySelector(MENU_SEL)
+      const legacyWired = menu === null ? 0 : enhanceLegacy(menu)
+      const genericWired = enhanceGeneric(legacyWired)
+
+      if (legacyWired + genericWired > 0) paintLastRun('上次结果：')
+      if (lastDiagnostics !== null) {
+        reportDiagnostics({
+          ...lastDiagnostics,
+          barCount: document.querySelectorAll('.dmd-allbar').length,
+          actionCount: document.querySelectorAll('.dmd-actions').length,
+        })
+      }
     }
 
     function scheduleEnhance() {

package/lib/index.js

@@ -325,6 +325,26 @@ async function writeStoredResults(snapshot) {
   }
 }
 
+/* ------------------------------------------------------------------ */
+/* 客户端自检上报（浏览器半把 DOM 定位结果写到这里，便于远程诊断）        */
+/* ------------------------------------------------------------------ */
+
+function clientReportFile() {
+  const base = process.env.DSH_HOME || join(homedir(), '.dsh')
+  return join(base, 'model-doctor-client-report.json')
+}
+
+async function writeClientReport(state) {
+  try {
+    const file = clientReportFile()
+    await mkdir(dirname(file), { recursive: true })
+    await writeFile(file, JSON.stringify(state), 'utf8')
+    return true
+  } catch {
+    return false
+  }
+}
+
 /* ------------------------------------------------------------------ */
 /* 权威模型目录                                                        */
 /* ------------------------------------------------------------------ */
@@ -614,6 +634,10 @@ export function apply(ctx) {
         const saved = await writeStoredResults(snapshot)
         return okResult({ ok: saved, at: snapshot.at })
       }
+      case 'clientReport': {
+        const saved = await writeClientReport(isRecord(request) ? request : {})
+        return okResult({ saved })
+      }
       default:
         return failResult('not-found', `未知端点 ${JSON.stringify(endpoint)}`)
     }
@@ -626,7 +650,7 @@ export function apply(ctx) {
     if (fetchRegistry === undefined || typeof fetchRegistry.register !== 'function') return
     routeCtx.effect(() => {
       const disposers = []
-      for (const endpoint of ['directory', 'check', 'checkAll', 'deleteModel', 'resultsLoad', 'resultsSave']) {
+      for (const endpoint of ['directory', 'check', 'checkAll', 'deleteModel', 'resultsLoad', 'resultsSave', 'clientReport']) {
         try {
           disposers.push(fetchRegistry.register({
             path: `${API_BASE}/${endpoint}`,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-model-doctor",
-  "version": "0.3.0",
-  "description": "模型医生：在对话输入区的模型选择菜单里，为每个模型选项追加「连通检测」与「删除」按钮——检测直连各网关探测连通性/欠费/额度，删除直接从 llm-pi-ai 配置移除模型（自动备份配置文档）。",
+  "version": "0.4.1",
+  "description": "模型医生：在对话输入区的模型选择菜单里，为每个模型选项追加「连通检测」与「删除」按钮——不依赖任何菜单渲染插件（官方原生菜单即可），检测直连各网关探测连通性/欠费/额度，删除直接从 llm-pi-ai 配置移除模型（自动备份配置文档）。",
   "keywords": [
     "deepseek",
     "deepseek-harness",