dsh-desktop-statusbar 2.1.2 → 2.2.1

package/lib/release-age.js

@@ -109,6 +109,73 @@ export function unionSelectors(selectors) {
   return versions.join(' || ')
 }
 
+/**
+ * 本插件在豁免列表里**最多保留几个版本**。
+ *
+ * 为什么要裁：早先的实现是只追加不清理，每更新一次就往同一条规则里多塞一个版本，
+ * 于是磁盘上长成 `2.0.0 || 2.0.1 || 2.1.0 || 2.1.1 || 2.1.2 || …`。它不会让安装失败
+ * （pnpm 认 `||` 并集），但有两个实际坏处：
+ *   · 规则无限变长，用户看不懂这一行在干什么；
+ *   · 更要紧的是当时还只保留**最早那条**，一旦某次真的写成两条同名规则，
+ *     pnpm 只认第一条 —— 新版本会被 24 小时发布年龄挡下。
+ *
+ * 保留 2 个（本次目标 + 上一次）而不是只留 1 个：用户升级后发现新版有问题，
+ * 想退回上一版时，上一版仍在豁免里，回滚不会被发布年龄策略拦。
+ * 更老的版本没有再回滚的现实意义（跨大版本回滚本就要手工处理配置/台账）。
+ */
+export const MAX_EXEMPT_VERSIONS = 2;
+
+/**
+ * 从一堆版本号里挑出该保留的：**目标版本必留**，再按出现顺序留最近的若干个。
+ *
+ * 不假设输入是升序（`||` 里的顺序是历史写入顺序，早期实现还可能乱序），
+ * 所以这里按**语义版本**排序后取最大的几个 —— 对于「最近」这个语义，
+ * 版本号大小比写入顺序更可靠。
+ *
+ * @param {string[]} versions 已有的版本号（可能乱序、可能重复）
+ * @param {string} target 本次要放行的版本
+ * @param {number} [keep] 最多保留几个
+ * @returns {string[]} 要保留的版本；目标版本排在最后（书写顺序：旧 → 新）
+ */
+export function keepRecentVersions(versions, target, keep = MAX_EXEMPT_VERSIONS) {
+  const all = []
+  const push = (one) => {
+    const text = String(one).trim()
+    if (text.length > 0 && all.includes(text) !== true) all.push(text)
+  }
+  versions.forEach(push)
+  push(target)
+  const limit = keep > 0 ? keep : 1
+  if (all.length <= limit) return all
+  /* 语义版本比较：把 x.y.z(-pre) 拆成数字段；解析不出数字的（理论上不会有，
+     ensureReleaseAgeExclude 已校验过版本形态）当作 0 处理，排在最后 */
+  const keyOf = (one) => String(one).split('-')[0].split('.').map((part) => Number(part) || 0)
+  const sorted = all.slice().sort((a, b) => {
+    const ka = keyOf(a)
+    const kb = keyOf(b)
+    for (let i = 0; i < 3; i += 1) {
+      if (ka[i] !== kb[i]) return ka[i] - kb[i]
+    }
+    return 0
+  })
+  /* 从最大的往下取 limit 个，再按升序写回去（读起来自然是旧 → 新） */
+  const picked = sorted.slice(Math.max(0, sorted.length - limit))
+  /* 目标版本必须在里面 —— 极端情况下（目标版本号小于已保留的那些）也要保住它 */
+  if (picked.includes(target) !== true) {
+    picked.sort((a, b) => {
+      const ka = keyOf(a)
+      const kb = keyOf(b)
+      for (let i = 0; i < 3; i += 1) {
+        if (ka[i] !== kb[i]) return ka[i] - kb[i]
+      }
+      return 0
+    })
+    picked.shift()
+    picked.push(target)
+  }
+  return picked.filter((one) => one.length > 0)
+}
+
 /** 去掉包裹标量的引号（成对才剥，与 parseExcludeBlock 同规则）。 */
 function unquoteScalar(value) {
   const text = String(value).trim()
@@ -269,6 +336,22 @@ function locateExcludeBlock(source) {
  */
 export function mergeExcludeIntoYaml(text, name, version, eol = '\n') {
   const source = String(text)
+  /* ------------------------------------------------------------------ 安全阀
+     这个函数改的是**共享文件** `pnpm-workspace.yaml`：写坏了不只是本插件装不上，
+     整个 profile 里所有插件都起不来（YAML `duplicated mapping key` → pnpm 拒绝解析）。
+
+     最坏的一种输入：文件里**已经有两个** `minimumReleaseAgeExclude:` 键
+     （历史遗留，或两个插件各自追加过）。`locateExcludeBlock` 只定位第一个块，
+     替换后第二个原样留着 —— 输出仍是两个同名键，照样把 profile 写坏。
+
+     这种状态下唯一安全的动作是**什么都不做**：返回 ok:false，调用方
+     （ensureReleaseAgeExclude）会把它转成结构化失败，安装流程继续走 ——
+     profile 没显式设这个策略时 pnpm 自己会豁免精确版本，安装本来就能成。
+     宁可这次豁免没生效，也绝不能把一个本来还能用的 profile 写坏。 */
+  const keyCount = (source.match(/^[ \t]*minimumReleaseAgeExclude:/gm) || []).length
+  if (keyCount > 1) {
+    return { ok: false, text: source, changed: false, reason: 'duplicate-key' }
+  }
   const found = locateExcludeBlock(source)
 
   if (found === null) {
@@ -281,11 +364,22 @@ export function mergeExcludeIntoYaml(text, name, version, eol = '\n') {
   const items = parseInlineValue(found.inline).concat(parseExcludeBlock(found.block))
   const byName = new Map()
   const order = []
+  /* 每个包名对应的一组「原始行」：块风格解析出来的条目带着逐字节原样的 `line`，
+     flow 风格的条目没有（它本来就要从 flow 重写成块），记 null。
+     别人的规则能用原始行时**必须原样写回** —— 早先每个条目都重新生成一遍，
+     结果 `dshmarket@1.66.22 || 1.66.32` 被加上引号变成 `'dshmarket@1.66.22 || 1.66.32'`。
+     语义虽然等价，但那是**别人的配置**，我们没有任何理由去改写它（用户的 diff 会脏）。 */
+  const rawLines = new Map()
   for (const item of items) {
     if (item.kind !== 'entry') continue
     const groupName = nameOfSelector(item.selector)
-    if (byName.has(groupName) !== true) { byName.set(groupName, []); order.push(groupName) }
+    if (byName.has(groupName) !== true) {
+      byName.set(groupName, [])
+      rawLines.set(groupName, [])
+      order.push(groupName)
+    }
     byName.get(groupName).push(item.selector)
+    rawLines.get(groupName).push(typeof item.line === 'string' ? item.line : null)
   }
 
   const mine = byName.get(name) ?? []
@@ -297,14 +391,22 @@ export function mergeExcludeIntoYaml(text, name, version, eol = '\n') {
   if (mine.length === 1 && versionOfSelector(mine[0]) === '') {
     return { ok: true, text: source, changed: false, reason: null }
   }
-  if (versions.includes(version)) {
-    /* 已经有这个版本：若只有一条规则，什么都不用改 */
-    if (mine.length === 1) return { ok: true, text: source, changed: false, reason: null }
-    /* 有多条我们的规则：合并成一条，避免 pnpm 只认第一条导致我们这条被忽略 */
+  /* 本插件的规则要**裁剪**：只留目标版本 + 最近一个（见 MAX_EXEMPT_VERSIONS）。
+     早先只追加不清理，历史版本会永久累积成一条越来越长的 `||` 列表。 */
+  const keptVersions = keepRecentVersions(versions, version)
+  const keptSelector = name + '@' + keptVersions.join(' || ')
+  if (mine.length === 1) {
+    const already = versionOfSelector(mine[0]).split('||').map((one) => one.trim()).filter((one) => one.length > 0)
+    /* 目标版本已在、且集合没变（不需要裁剪）→ 一个字节都不动，保持幂等 */
+    if (already.length === keptVersions.length && keptVersions.every((one) => already.includes(one))) {
+      return { ok: true, text: source, changed: false, reason: null }
+    }
   }
-  if (byName.has(name) !== true) order.push(name)
-  if (byName.has(name) !== true) byName.set(name, [])
-  byName.get(name).push(name + '@' + version)
+  /* 用裁剪后的版本集合替换该包名的条目（不是追加） */
+  byName.set(name, [keptSelector])
+  /* 我们这条要**重新生成**（没有可原样复用的原始行），所以原始行记 null */
+  rawLines.set(name, [null])
+  if (order.indexOf(name) === -1) order.push(name)
 
   /* 重排这个块：每个包名一条，位置取它首次出现的地方；注释原样保留在最前。 */
   const comments = items.filter((item) => item.kind === 'comment')
@@ -312,6 +414,23 @@ export function mergeExcludeIntoYaml(text, name, version, eol = '\n') {
   for (const item of comments) lines.push(item.line)
   for (const groupName of order) {
     const selectors = byName.get(groupName) ?? []
+    const raws = rawLines.get(groupName) ?? []
+    /* 我们自己的那条：用裁剪后的版本集合重新生成 */
+    if (groupName === name) {
+      const merged = versionOfSelector(keptSelector)
+      const selector = merged.length === 0 ? groupName : groupName + '@' + merged
+      lines.push('  - ' + (selector.startsWith('@') || selector.includes(' || ') ? "'" + selector.replace(/'/g, "''") + "'" : selector))
+      continue
+    }
+    /* 别人的规则：只要它还是**一条且原始行可用**，就原样写回。
+       唯一例外是缩进 —— 重排后整个块统一用两空格缩进，零缩进的旧条目必须跟着对齐，
+       否则同一个序列里混着两种缩进，YAML 直接解析失败（实测过）。
+       所以这里只动**前导空白**，`-` 之后的正文（含引号、`||`、大小写）一个字节都不改。 */
+    if (raws.length === 1 && typeof raws[0] === 'string' && raws[0].length > 0) {
+      const body = raws[0].replace(/^[ \t]*/, '')
+      lines.push('  ' + body)
+      continue
+    }
     const merged = unionSelectors(selectors)
     /* pnpm 把同名的多条并成一条；只有一个版本时保持 `name@version` 的朴素写法 */
     const selector = merged.length === 0 ? groupName : groupName + '@' + merged

package/lib/self-update.js

@@ -89,54 +89,237 @@ export function resolveSelfDir(moduleUrl) {
 }
 
 /**
- * 定位 pnpm 可执行文件。
+ * 取一个「可能是字符串」的注入值：类型不对时退回默认值。
+ * 传 `null` / 数字 / 对象都按「显式给了一个不可用的值」处理，不回退。
  *
- * 顺序：
- *   1. 环境变量 `DSH_DESKTOP_STATUSBAR_PNPM`：完整命令覆盖。可以是 JSON 数组
- *      （`["node","/path/pnpm.mjs"]`，用别的 node 跑打包的 pnpm 或包一层脚本时用），
- *      也可以是单个可执行文件路径。
- *   2. 宿主随包提供的 pnpm：从 `process.execPath` 推出 resources 目录。
- *      DSH 桌面端把 pnpm 放在 `resources/runtime/pnpm/bin/pnpm.mjs`，
- *      用 Electron 可执行文件加 `ELECTRON_RUN_AS_NODE=1` 启动即可当 node 用
- *      （官方插件管理器走的也是这条路）。
- *   3. PATH 上的 `pnpm`（web 端 / CLI 运行时常走这条）。
+ * @param {unknown} value 注入值
+ * @param {unknown} fallback 默认值
+ * @returns {string}
+ */
+function asText(value, fallback) {
+  if (value === undefined) return typeof fallback === 'string' ? fallback : ''
+  return typeof value === 'string' ? value : ''
+}
+
+/**
+ * 判断一段文本看起来是不是绝对路径。
  *
- * @returns {{command: string, args: string[], electron: boolean}|null}
+ * 不用 `node:path` 的 `isAbsolute()`：它按**当前进程**的平台判断，而这里允许测试
+ * 注入 `options.platform`，两者可能对不上。两种平台的写法都认：
+ * `C:\x`（盘符）、`\\server\share`（UNC）、`/x`（POSIX 根）。
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+function looksAbsolutePath(text) {
+  return /^[A-Za-z]:[\\/]/.test(text)
+    || text.startsWith('\\\\')
+    || text.startsWith('/')
+}
+
+/**
+ * 去掉路径结尾的分隔符；盘符根（`C:\`）原样保留 —— 去掉会变成 `C:`。
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function trimTrailingSeparators(text) {
+  let out = text
+  while (out.length > 1 && /[\\/]$/.test(out) === true) {
+    if (/^[A-Za-z]:[\\/]$/.test(out) === true) break
+    out = out.slice(0, -1)
+  }
+  return out
+}
+
+/**
+ * 解析安装根下的 `resources` 目录。
+ *
+ * 优先级（与宿主自己的 `runtimeResources()` 取值顺序一致）：
+ *   1. 显式注入的 `resourcesPath`（测试用，也可以是调用方认定的权威值）；
+ *   2. `process.resourcesPath` —— Electron 打包版给的权威值，比推断更稳；
+ *   3. 由 `execPath` 推断：`dirname(execPath)/resources`（非 Electron 环境兜底）。
+ *
+ * @param {string} resourcesPath 已处理过默认值（可能是空字符串）
+ * @param {string} execPath 已处理过默认值（可能是空字符串）
+ * @returns {string|null} 推断不出来时返回 null
+ */
+function resolveResourcesDir(resourcesPath, execPath) {
+  if (resourcesPath.length > 0 && looksAbsolutePath(resourcesPath) === true) {
+    return trimTrailingSeparators(resourcesPath)
+  }
+  if (execPath.length > 0) return trimTrailingSeparators(join(dirname(execPath), 'resources'))
+  return null
+}
+
+/**
+ * 定位 pnpm，返回**结构化结果**（永不抛异常），把「试过哪些候选」一并带回。
+ *
+ * 只做定位，不执行任何外部命令。
+ *
+ * 候选顺序（命中即返回，逐个记进 `tried`）：
+ *   1. `DSH_DESKTOP_STATUSBAR_PNPM`：插件自己的覆盖口，优先级最高。可以是 JSON 数组
+ *      （`["node","/path/pnpm.mjs"]`，用别的 node 跑打包的 pnpm 时用），也可以是
+ *      单个可执行文件路径。**不检查文件是否存在** —— 用户显式指定的入口就该照办。
+ *   2. `DSH_DESKTOP_PNPM_ENTRY`：宿主自己的口径（宿主 `runtimeResources()` 在开发
+ *      模式下读它）。排在文件候选之前，宿主以后挪位置也不会失配。
+ *   3. 宿主随包提供的 pnpm，按 `resources` 目录拼出来，三条候选依次尝试：
+ *      - `runtime/primary-runtime/dependencies/pnpm/bin/pnpm.mjs`：**当前宿主布局**。
+ *        优先用同一套运行时里的 node（`runtime/primary-runtime/dependencies/node/bin/node.exe`）
+ *        去跑它，不依赖 Electron 的 `ELECTRON_RUN_AS_NODE`；那套 node 不在时退回宿主可执行文件
+ *        （此时才需要 `ELECTRON_RUN_AS_NODE=1`）。
+ *      - `runtime/pnpm/bin/pnpm.mjs`：更旧的宿主布局，保留兼容。
+ *      - `app.asar.unpacked/dsh/node_modules/pnpm/bin/pnpm.mjs`：再旧的打包布局，保留兼容。
+ *
+ * 找不到时**不做 PATH 搜索**：Windows 上 PATH 里多半是 `pnpm.cmd`，spawn 它需要
+ * `shell: true`，等于把命令解释权交给 shell，风险面大于收益。真需要时请用户用
+ * `DSH_DESKTOP_STATUSBAR_PNPM` 直接指定（issue 里的绕过写法就是这么用的）。
+ *
+ * @param {{
+ *   env?: {[key: string]: string|undefined},
+ *   execPath?: string,
+ *   resourcesPath?: string,
+ *   exists?: (path: string) => boolean,
+ *   electron?: boolean,
+ *   platform?: string,
+ * }} [options] 全部可选；只有测试会传
+ * @returns {{
+ *   ok: boolean,
+ *   runner: {command: string, args: string[], electron: boolean}|null,
+ *   source: 'custom-env'|'host-env'|'primary-runtime'|'runtime-legacy'|'asar-unpacked'|null,
+ *   tried: Array<{source: string, path: string|null, note: string}>,
+ * }}
  */
-export function resolvePnpm() {
-  const explicit = process.env.DSH_DESKTOP_STATUSBAR_PNPM
-  if (typeof explicit === 'string' && explicit.trim().length > 0) {
-    const text = explicit.trim()
-    if (text.startsWith('[')) {
+export function resolvePnpmDetailed(options) {
+  const opts = options === null || typeof options !== 'object' ? {} : options
+  /** 环境变量来源；默认 process.env。 */
+  const env = opts.env === undefined ? process.env : (opts.env === null ? {} : opts.env)
+  /** 宿主可执行文件；空字符串表示「拿不到」。 */
+  const execPath = asText(opts.execPath, process.execPath)
+  /** 注入的 resources 目录；未传时才回落到 process.resourcesPath。 */
+  const resourcesPath = asText(opts.resourcesPath, process.resourcesPath)
+  /** 是否跑在 Electron 里 —— 只有退回宿主可执行文件当 node 用时才需要它。 */
+  const electron = opts.electron === undefined
+    ? (typeof process.versions === 'object'
+      && process.versions !== null
+      && typeof process.versions.electron === 'string'
+      && process.versions.electron.length > 0)
+    : opts.electron === true
+  /** 平台；只用来决定同套运行时里的 node 叫 node.exe 还是 node。 */
+  const platform = asText(opts.platform, process.platform)
+
+  /** 每次尝试的记录：命中的也记，失败时一并带回给调用方写日志。 */
+  const tried = []
+  /** 记一条命中并直接返回成功结果。 */
+  const hit = (source, runner, path) => {
+    tried.push({ source, path: typeof path === 'string' ? path : null, note: '命中' })
+    return { ok: true, runner, source, tried }
+  }
+  /** 记一条未命中，继续试下一个候选。 */
+  const miss = (source, path, note) => {
+    tried.push({ source, path: typeof path === 'string' ? path : null, note })
+  }
+  /** 全部落空。 */
+  const fail = () => ({ ok: false, runner: null, source: null, tried })
+  /** 文件存在性检查；注入的实现抛错也当成「不存在」，保证本函数永不抛。 */
+  const exists = (target) => {
+    if (typeof opts.exists === 'function') {
+      try { return opts.exists(target) === true } catch (error) { return false }
+    }
+    try { return existsSync(target) === true } catch (error) { return false }
+  }
+
+  /* 1) 插件自己的覆盖口：完全不检查文件是否存在（用户显式指定的入口） */
+  const custom = asText(env.DSH_DESKTOP_STATUSBAR_PNPM, '')
+  if (custom.trim().length > 0) {
+    const text = custom.trim()
+    if (text.startsWith('[') === true) {
+      let parsed = null
       try {
-        const parsed = JSON.parse(text)
-        if (Array.isArray(parsed) === true && parsed.length > 0 && parsed.every((one) => typeof one === 'string')) {
-          return { command: parsed[0], args: parsed.slice(1), electron: false }
+        const value = JSON.parse(text)
+        if (Array.isArray(value) === true && value.length > 0 && value.every((one) => typeof one === 'string') === true) {
+          parsed = value
         }
       } catch (error) {
-        /* 不是合法数组就当单路径处理 */
+        /* 不是合法数组，落到下面的单路径处理 */
       }
+      if (parsed !== null) {
+        return hit('custom-env', { command: parsed[0], args: parsed.slice(1), electron: false }, custom)
+      }
+      /* `'[]'` 也走这里：空数组不够当命令用，退化成单路径（保持旧行为） */
+      miss('custom-env', custom, '不是合法 JSON 数组，按单路径处理')
     }
-    return { command: text, args: [], electron: false }
+    return hit('custom-env', { command: text, args: [], electron: false }, custom)
   }
 
-  const execPath = process.execPath
-  if (typeof execPath === 'string' && execPath.length > 0) {
-    const resources = join(dirname(execPath), 'resources')
-    const candidates = [
-      join(resources, 'runtime', 'pnpm', 'bin', 'pnpm.mjs'),
-      join(resources, 'app.asar.unpacked', 'dsh', 'node_modules', 'pnpm', 'bin', 'pnpm.mjs'),
-    ]
-    for (const candidate of candidates) {
-      try {
-        if (existsSync(candidate)) return { command: execPath, args: [candidate], electron: true }
-      } catch (error) {
-        /* 试下一个 */
-      }
+  /* 2) 宿主自己的口径：只存在于开发模式，但插件照样优先认它 */
+  const hostEntry = asText(env.DSH_DESKTOP_PNPM_ENTRY, '')
+  if (hostEntry.trim().length > 0) {
+    const entry = hostEntry.trim()
+    if (execPath.length === 0) {
+      miss('host-env', hostEntry, '没有可用的宿主可执行文件')
+    } else if (exists(entry) === true) {
+      /* tried.path 记变量原值（契约口径），实际执行用去掉首尾空白的路径 */
+      return hit('host-env', { command: execPath, args: [entry], electron }, hostEntry)
+    } else {
+      miss('host-env', hostEntry, '不存在')
     }
   }
 
-  return null
+  /* 3) 按 resources 目录拼出来的文件候选 */
+  const resources = resolveResourcesDir(resourcesPath, execPath)
+  if (resources === null) {
+    miss('primary-runtime', null, '无法推断 resources 目录')
+    return fail()
+  }
+
+  /* 3.1 当前宿主布局：优先用同一套运行时里的 node，不碰 ELECTRON_RUN_AS_NODE */
+  const primaryPnpm = join(resources, 'runtime', 'primary-runtime', 'dependencies', 'pnpm', 'bin', 'pnpm.mjs')
+  if (exists(primaryPnpm) === true) {
+    const primaryNode = join(resources, 'runtime', 'primary-runtime', 'dependencies', 'node', 'bin', platform === 'win32' ? 'node.exe' : 'node')
+    if (exists(primaryNode) === true) {
+      return hit('primary-runtime', { command: primaryNode, args: [primaryPnpm], electron: false }, primaryPnpm)
+    }
+    if (execPath.length > 0) {
+      return hit('primary-runtime', { command: execPath, args: [primaryPnpm], electron }, primaryPnpm)
+    }
+    miss('primary-runtime', primaryPnpm, '找到 pnpm，但同套运行时里的 node 与宿主可执行文件都不可用')
+  } else {
+    miss('primary-runtime', primaryPnpm, '不存在')
+  }
+
+  /* 3.2 / 3.3 旧布局：向后兼容，用宿主可执行文件加 ELECTRON_RUN_AS_NODE 去跑 */
+  const legacyCandidates = [
+    { source: 'runtime-legacy', file: join(resources, 'runtime', 'pnpm', 'bin', 'pnpm.mjs') },
+    { source: 'asar-unpacked', file: join(resources, 'app.asar.unpacked', 'dsh', 'node_modules', 'pnpm', 'bin', 'pnpm.mjs') },
+  ]
+  for (const candidate of legacyCandidates) {
+    if (exists(candidate.file) !== true) {
+      miss(candidate.source, candidate.file, '不存在')
+      continue
+    }
+    if (execPath.length === 0) {
+      miss(candidate.source, candidate.file, '找到 pnpm，但没有可用的宿主可执行文件')
+      continue
+    }
+    return hit(candidate.source, { command: execPath, args: [candidate.file], electron }, candidate.file)
+  }
+
+  return fail()
+}
+
+/**
+ * 定位 pnpm 可执行文件（向后兼容的薄包装）。
+ *
+ * 内部走 `resolvePnpmDetailed()`，只关心「最终能不能跑」，不关心试过哪些候选。
+ * 现有测试与 `verify-self-update.js --online` 用的都是这个签名。
+ *
+ * @param {object} [options] 透传给 resolvePnpmDetailed（测试注入用）
+ * @returns {{command: string, args: string[], electron: boolean}|null}
+ */
+export function resolvePnpm(options) {
+  const detail = resolvePnpmDetailed(options)
+  return detail.ok === true ? detail.runner : null
 }
 
 /**
@@ -231,9 +414,9 @@ export const RELEASE_AGE_OVERRIDE = '--config.minimum-release-age=0'
  *   - `--save-exact`：清单里写死精确版本，避免 `^` 范围日后漂移。
  *   - 发布年龄归零：见 RELEASE_AGE_OVERRIDE。
  *
- * 不加 `--no-frozen-lockfile`：pnpm 11.7.0 的 `add` 不认这个选项
- * （实测报 `Unknown option: 'frozen-lockfile'`）。`add` 本来就会更新锁文件，
- * 不需要它。
+ * 不加 `--no-frozen-lockfile`：pnpm 11 的 `add` 不认这个选项
+ * （实测报 `Unknown option: 'frozen-lockfile'`；宿主当前自带 pnpm 11.28.5，同样如此）。
+ * `add` 本来就会更新锁文件，不需要它。
  *
  * @param {string[]} base pnpm 自身的参数（例如打包 pnpm 的 .mjs 路径）
  * @param {string} target 安装目标 `包名@版本`
@@ -257,14 +440,30 @@ export async function runSelfUpdate(options) {
      刷新页面不算数 —— 插件包元数据（含 client.js 的 revision）在启动时缓存、直到重启才更新
      （见 @deepseek-ai/dsh-hmr 的已知限制与 dsh-client-modules 的说明）。
      不用「要不要重启」去猜，直接如实告诉界面。 */
-  const result = { ok: false, from, to: options.version, reason: null, detail: null, profileDir: null, changedExclude: false, restartRequired: true }
+  const result = { ok: false, from, to: options.version, reason: null, detail: null, profileDir: null, changedExclude: false, restartRequired: true, tried: [] }
 
-  const pnpm = resolvePnpm()
-  if (pnpm === null) {
+  /* 注意：必须在找 profile 之前就报 pnpm-not-found —— 找不到 pnpm 时 profile
+     目录是否存在无关紧要，先告诉用户真正的卡点。 */
+  const pnpm = resolvePnpmDetailed()
+  if (pnpm.ok !== true) {
     result.reason = 'pnpm-not-found'
+    /* 把试过的候选写进结果和日志：issue 里那次排查全靠手工逐条 Test-Path，
+       以后用户/开发者看日志就能定位，不用再猜插件找的是哪条路径。 */
+    result.tried = pnpm.tried
+      .slice(0, 12)
+      .map((one) => {
+        const where = one.path === null ? '—' : one.path
+        const line = one.source + ': ' + where + '（' + one.note + '）'
+        return line.length > 300 ? line.slice(0, 300) + '…' : line
+      })
+    log('update: pnpm-not-found，尝试过：')
+    for (const line of result.tried) log('  - ' + line)
     return result
   }
 
+  const runner = pnpm.runner
+  log('update: pnpm 来源 ' + pnpm.source + ' → ' + runner.command + ' ' + runner.args.join(' ') + (runner.electron === true ? '（ELECTRON_RUN_AS_NODE）' : ''))
+
   const profileDir = findProfileDir(selfDir)
   result.profileDir = profileDir
   if (profileDir === null) {
@@ -285,13 +484,13 @@ export async function runSelfUpdate(options) {
   /* 精确版本，不用 @latest：后者在发布年龄策略下会静默装成旧的成熟版 */
   const target = SELF_NAME + '@' + options.version
   const env = { ...process.env }
-  if (pnpm.electron === true) env.ELECTRON_RUN_AS_NODE = '1'
+  if (runner.electron === true) env.ELECTRON_RUN_AS_NODE = '1'
   /* CI=true：pnpm 在非交互环境下不会弹提示卡住（与官方插件管理器同一做法） */
   env.CI = 'true'
-  const args = updateArgs(pnpm.args, target)
+  const args = updateArgs(runner.args, target)
 
   log('update: 开始安装 ' + target)
-  const run = await runCommand(pnpm.command, args, {
+  const run = await runCommand(runner.command, args, {
     cwd: profileDir,
     env,
     timeoutMs: options.timeoutMs,

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "dsh-desktop-statusbar",
-  "version": "2.1.2",
+  "version": "2.2.1",
   "type": "module",
   "description": "把 DSH 桌面端对话区底部的统计行换成可配置状态栏：10 个字段可选可排序，按官方峰谷口径估算费用，支持自定义模型单价与账户余额。",
   "icon": "icon.svg",
   "license": "MIT",
   "engines": {
-    "node": "^22.19.0 || >=24.0.0"
+    "node": "^22.19.0 || >=24.0.0",
+    "dsh": ">=0.2.0-rc.2"
   },
   "author": "北浮森屿 (https://github.com/raphael-y7)",
   "repository": {