dsh-app-updater 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -2,6 +2,62 @@
 
 本项目遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
 
+## [1.3.0] — 2026-10-31
+
+### 修复
+
+- **机器级安装全部失败的问题**：进程没有管理员令牌时，MSI 直接失败（msiexec 1603，
+  MSI 日志里是 `Error 1925: You do not have sufficient privileges…`），而部分安装器是
+  **静默退出 0 却什么都没装**（实测 Logitech G HUB）。两个现象同源，都是权限。
+- **安装后复核**：退出码 0 不再等于成功。安装完成后用「安装前版本 / 安装后版本 / 目标版本」
+  判断是否真的生效，没生效就如实报失败 —— 原来只看退出码，会把 G HUB 那种
+  「退出码 0、版本没变」的情况误报成「更新完成」。
+- **架构过滤回退**：`winget download/upgrade --architecture x64` 在清单里没有该架构时现在能
+  正确识别（中文报错是「找不到适用的安装程序」，旧正则只匹配了「没有适用」）并退回不限架构
+  重试；`winget upgrade` 兜底同时补上 `--include-unknown`（虎牙直播的已装版本被读成 Unknown，
+  不带它直接「目录里没有适用的更新」）。
+- **Edge**：winget 目录里的 `Microsoft.Edge` 是企业版 MSI，与本机消费版 Edge 的安装技术不匹配，
+  winget 直接拒绝（`0x8A15008E`「安装技术与当前安装的版本不同，请卸载包并安装较新版本」），
+  现在先走 Edge 自带的更新服务 `MicrosoftEdgeUpdate.exe /ua`；若它没生效（实测该机的
+  EdgeUpdate 引擎目录是 `1.3.311.5` 而服务主程序还是 `1.3.275.13`，服务起不来，`/ua` 直接
+  `0x80070002`），自动退回安装 winget 目录里的官网全量包（企业版 MSI，提权执行）——
+  实测这一步能把 Edge 正常装到目标版本，winget 拒绝执行只是因为它的策略。
+- **读不到版本的应用**：虎牙直播的卸载信息里没有版本号，winget 永远显示 `Unknown`。
+  复核阶段不再把它误判为失败，改为「已安装、未复核」写进结果与日志。
+- **「安装包不生效」的软件给出可操作提示**：实测 Logitech G HUB 的更新包早已下载到
+  `%ProgramData%\LGHUB\next.json` 指向的 depots（build 880806 / 2026.7.992920），但安装器
+  `--silent` 与 `winget upgrade` 都会在 3 秒内退出 0 且什么都不装，只有**启动 G HUB 本体**
+  之后 `current.json` 才跳到新版本。插件承诺不启动用户的软件，所以这类情况现在会在失败
+  原因里直接给出「手动打开一次该应用即可完成升级」的提示（`updateHintFor`）。
+- **MSI 日志**：MSI 安装现在带 `/l*v <下载目录>\<包名>.msi.log`，失败时把日志路径写进错误信息
+  （「Error 1925」就是这么被找到的）。
+- **残留清单**：关闭「保留安装包」时，现在连 winget 落盘的 `.yaml` 清单一并删除。
+
+### 新增
+
+- **自动提权安装**（`lib/elevate.js`）：需要管理员的安装类命令交给 `Start-Process -Verb RunAs`
+  的提权副本执行，退出码与输出写进临时文件后读回。新增开关「自动提权安装」（默认开启）。
+  UAC 为「始终通知」时每次安装会弹一次确认；把 `ConsentPromptBehaviorAdmin` 设为 0
+  （管理员静默提权）时完全无感。
+- 说明：提权副本是独立进程，取消更新只会停掉启动器，已经开始的那次安装会自己跑完。
+
+### 安全
+
+- **接入宿主 connection 准入**（插件市场 dshopen.org 对 1.2.0 的复核意见）：所有
+  `/dsh-app-updater/*` 路由先过 `ctx.connection.admit(request)` —— DSH 用来做 Host/Origin
+  信任校验与浏览器会话 / API 认证的那套边界，宿主自己的 `/api` 路由用的就是它。
+  未通过准入的请求直接得到 `401`/`403`；带凭据的请求一律以准入结果为准。
+  只有在宿主没有 `connection` 服务、或者请求不带任何连接凭据且来自回环地址时，才退回旧的
+  「回环」规则，并在响应头标注 `X-DSH-Admission: loopback-legacy`（宿主自己的 Electron
+  载体与本机脚本都不带 Cookie，需要一个不误伤它们的路径）。
+- 因此 README 里「用 curl 直接改设置」的例子现在需要带上 DSH 的会话 Cookie，或在
+  `connection` 不可用的宿主上从回环地址调用。
+
+### 说明
+
+- 读类命令（`winget list` / `upgrade --include-unknown` / `--version`）不提权。
+- `update.results[]` 新增 `installOk`（安装器自身是否报成功）与 `manifest`（落盘的清单位置）。
+
 ## [1.2.0] — 2026-10-31
 
 ### 新增

package/CONTRACT.md

@@ -27,10 +27,24 @@ dsh-app-updater/
 - 架构匹配：`settings.matchSystemArch !== false` 时，Windows 侧把 `env.wingetArch` 传给
   `winget download/upgrade --architecture`；清单缺该架构时自动退回自动匹配并写日志。
   macOS 侧由 Homebrew 决定 cask 架构。
+- 提权（`lib/elevate.js`）：`settings.autoElevate !== false` 且当前进程没有管理员令牌时，
+  安装类命令（安装包本体、`winget upgrade` 兜底）交给 `Start-Process -Verb RunAs` 的提权副本
+  执行，退出码与输出写进临时文件后读回；`cancelled` 表示 UAC 被取消（1223）。
+  读类命令（`winget list` / `upgrade --include-unknown` / `--version`）不提权。
+- 复核：安装后必须用「安装前版本 / 安装后版本 / 目标版本」判断是否真的生效，退出码 0 不算成功
+  （机器级安装包在未提权时会静默退出 0 却什么都没装）。`update.results[].installOk` 记录
+  安装器自身是否报成功，`verified` 记录复核时读到的版本。
+- 自带更新服务：Edge 的 winget 目录条目是企业版 MSI，与本机消费版安装技术不匹配
+  （`0x8A15008E`），改走 `MicrosoftEdgeUpdate.exe /ua`，再由复核轮询确认版本就位。
 
 ## 宿主 HTTP 路由
 
-全部 `kind: "exact"`，前缀 `/dsh-app-updater/`。写操作要求 loopback + `confirm: true`。
+全部 `kind: "exact"`，前缀 `/dsh-app-updater/`。每个请求先过 **connection 准入**：
+`ctx.connection.admit(req)`（DSH 的 Host/Origin 信任校验 + 浏览器会话 / API 认证，
+宿主自己的 `/api` 路由用的同一套），被拒即返回 `401`（未认证）/ `403`（不可信来源）；
+写操作再要求 `confirm: true`。
+宿主没有 `connection` 服务、或请求不带任何连接凭据且来自回环地址时，退回旧的「回环」检查，
+并在响应头标注 `X-DSH-Admission: loopback-legacy`（`lib/index.js` 的 `admissionGate`）。
 
 ### GET /dsh-app-updater/state.json
 
@@ -48,7 +62,7 @@ dsh-app-updater/
   "update": { "running": false, "total": 0, "done": 0, "current": null, "error": null },
   "apps": { "scannedAt": 0, "stats": { "total": 0, "upgradable": 0, "unsupported": 0 }, "items": [], "engine": "winget" },
   "log": [ { "at": 0, "level": "info|warn|error|success", "text": "..." } ],
-  "settings": { "includeStoreApps": true, "includeRegistryOnly": true, "downloadDir": "", "keepInstallers": true, "hashFallbackUpgrade": true, "dryRun": false, "matchSystemArch": true }
+  "settings": { "includeStoreApps": true, "includeRegistryOnly": true, "downloadDir": "", "keepInstallers": true, "hashFallbackUpgrade": true, "dryRun": false, "matchSystemArch": true, "autoElevate": true }
 }
 ```
 
@@ -81,11 +95,30 @@ body `{ "confirm": true, "force": true }` → `{ "ok": true, "started": true }`
 ### POST /dsh-app-updater/update
 
 body `{ "confirm": true, "ids": ["Google.Chrome", "..."], "mode": "silent" }`
-→ `{ "ok": true, "started": true, "queued": 3 }`（串行执行，逐条下载官网全量包 → 校验 → 静默安装）
+→ `{ "ok": true, "started": true, "queued": 3 }`
+（串行执行，逐条：下载官网全量包 → 校验哈希 → 静默安装（需要管理员时自动提权）→ 复核版本。
+Edge 由 `MicrosoftEdgeUpdate.exe /ua` 处理。`settings.dryRun` 时只下载、不安装、不复核。）
+
+`update.results[]`（每条一次更新）：
+
+```jsonc
+{
+  "id": "Microsoft.Edge",
+  "ok": false,              // 最终结论：复核不通过就是 false，哪怕安装器报成功
+  "installOk": true,        // 安装器自身是否报成功（退出码 0 / winget 成功）
+  "error": "安装报告成功，但没有生效：版本没有变化（仍为 156.0.4314.50，目标 156.0.4314.58）",
+  "installer": "C:\\...\\Microsoft Edge_156.0.4314.58_Machine_X64_msi_en-US.msi",
+  "manifest": "C:\\...\\Microsoft Edge_156.0.4314.58_Machine_X64_msi_en-US.yaml",
+  "verified": "156.0.4314.50",   // 复核时读到的已装版本
+  "selfUpdater": "edgeupdate",  // 走自带更新服务时存在
+  "note": "已交给 Microsoft Edge 更新服务，等待版本就位",
+  "durationMs": 33288
+}
+```
 
 ### POST /dsh-app-updater/cancel
 
-→ `{ "ok": true }`（取消尚未开始的项目；正在安装的进程会收到终止请求）
+→ `{ "ok": true }`（取消尚未开始的项目；提权副本是独立进程，取消只会停掉启动器，已经开始的那次安装会自己跑完）
 
 ### POST /dsh-app-updater/settings
 

package/README.en.md

@@ -95,6 +95,7 @@ State file: `%USERPROFILE%\.dsh\dsh-app-updater\state.json`
 | `hashFallbackUpgrade` | `true` | Fall back to `winget upgrade` when the download fails. |
 | `dryRun` | `false` | **Rehearsal mode**: download the vendor's full installer but never install it. |
 | `matchSystemArch` | `true` | Match the installer to the detected system and CPU architecture (Windows passes `--architecture`; macOS is resolved by Homebrew). |
+| `autoElevate` | `true` | **Automatic elevation**: install commands that need administrator rights run in an elevated copy (UAC prompts once per install, when UAC prompts at all). |
 
 Everything above is editable from the plugin's own settings panel inside the settings page.
 The panel also accepts API calls:
@@ -113,8 +114,15 @@ curl -X POST -H "Content-Type: application/json" \
   `settings` / `open-downloads` accept only requests from loopback with `confirm:true`.
 - **No guessed silent switches**: the publisher's declared `Silent` switches are preferred;
   generic defaults are used only when a manifest is unavailable.
-- **No silent elevation**: installers that need administrator rights show the normal UAC prompt.
-- **Version is verified after installing** and recorded in the log.
+- **Elevation only for installs, and on demand**: install commands that need administrator rights
+  (MSI packages, installers writing into `Program Files`, the `winget upgrade` fallback) run in an
+  elevated copy through `Start-Process -Verb RunAs`. With UAC set to "always notify" you get one
+  prompt per install; with `ConsentPromptBehaviorAdmin = 0` it is completely silent. Reads
+  (`winget list` / `upgrade --include-unknown` / `--version`) never elevate.
+- **A zero exit code is not success**: after installing, the plugin compares the installed version
+  against the target version and reports a failure when nothing actually changed — machine-scope
+  installers silently exit 0 without installing anything when they lack administrator rights
+  (Logitech G HUB used to be reported as "updated" that way).
 - **System components** (`.NET`, VC++ runtimes, …) are listed but not updated by default.
 - **Only its own directory is written**: state and logs live in `~/.dsh/dsh-app-updater/`.
 

package/README.md

@@ -13,6 +13,9 @@
 dsh plugin --profile web add dsh-app-updater
 ```
 
+> 刚发布的新版本可能被 pnpm 的 `minimumReleaseAge` 策略暂缓一段时间；想立刻装到指定版本就显式写版本号：
+> `dsh plugin --profile web add dsh-app-updater@1.2.0`（细节见 [RELEASING.md](RELEASING.md)）。
+
 不想走 npm，也可以用源码或发行包：
 
 ```bash
@@ -97,6 +100,7 @@ dsh plugin --profile web add https://github.com/19952730389/dsh-app-updater/rele
 | `hashFallbackUpgrade` | `true` | 下载失败时退回 `winget upgrade` 兜底。 |
 | `dryRun` | `false` | **演练模式**：只下载官网全量安装包、不执行安装。用来先看会装什么。 |
 | `matchSystemArch` | `true` | 按识别到的系统与芯片架构挑选安装包（Windows 传 `--architecture`；macOS 由 Homebrew 决定）。 |
+| `autoElevate` | `true` | **自动提权安装**：需要管理员的安装包（MSI、写入 `Program Files`）改由管理员上下文执行；UAC 开启时每次安装会弹一次确认。 |
 
 用 API 改设置（等价于设置面板，适合脚本化）：
 
@@ -113,10 +117,17 @@ curl -X POST -H "Content-Type: application/json" \
 
 ## 安全边界
 
-- **写操作全部要求本机来源 + 显式确认**：`scan` / `update` / `cancel` / `settings` / `open-downloads` 只接受 loopback 请求且必须带 `confirm:true`。
+- **接入宿主 connection 准入**：每个请求先过 `ctx.connection.admit(request)` —— DSH 用来做
+  Host/Origin 信任校验与浏览器会话 / API 认证的那套边界（宿主自己的 `/api` 路由用的就是它），
+  未通过的请求直接得到 `401`/`403`。宿主没有 `connection` 服务、或请求不带任何连接凭据且来自
+  回环地址时，退回旧的「回环」规则，并在响应头标注 `X-DSH-Admission: loopback-legacy`。
+- **写操作还要显式确认**：`scan` / `update` / `cancel` / `settings` / `open-downloads` 必须带 `confirm:true`。
 - **不猜测静默参数**：优先用发布方在清单里声明的 `Silent` 参数；清单缺失时才按安装包类型用保守的默认开关。
-- **不静默提权**：需要管理员权限的安装包会正常弹出 UAC，由你决定是否放行。
-- **安装后复核版本**：更新完会重新查询一次版本并记录，日志里能看到「更新完成，当前版本 X」。
+- **需要管理员时自动提权**：机器级安装包（MSI、写入 `Program Files`）交给
+  `Start-Process -Verb RunAs` 的提权副本执行（可在设置里关掉「自动提权安装」）；
+  UAC 为「始终通知」时每次安装会弹一次确认。
+- **安装后复核版本**：用「安装前 / 安装后 / 目标」三个版本判断这次更新是否真的生效 ——
+  退出码 0 不再等于成功（机器级安装包在没提权时会静默退出 0 却什么都没装）。
 - **不做系统组件更新**：`.NET` 运行时、VC++ 运行库等仍会列出来，但默认不作为一键更新的目标。
 - **只写自己的目录**：状态与日志写在 `~/.dsh/dsh-app-updater/`，不碰 profile 与宿主配置。
 
@@ -181,6 +192,15 @@ node test/harness.mjs --scan    # 用假 cordis ctx + 真 HTTP 把宿主半身
 
 还可以在设置面板里关掉「按本机架构安装包」——关闭后把选择权交回 winget 自己（Homebrew 一直按本机架构）。
 
+机器级安装（MSI、写入 `Program Files`）需要管理员权限，否则 MSI 会返回 1603（MSI 日志里是
+`Error 1925: You do not have sufficient privileges…`），部分安装器则可能**静默退出 0 却什么都没装**。
+因此安装类命令默认自动提权执行（设置里的「自动提权安装」，默认开启）：安装包本体与
+`winget upgrade` 兜底都交给 `Start-Process -Verb RunAs` 的提权副本，装完再按
+「安装前版本 / 安装后版本 / 目标版本」复核这次更新是否真的生效。
+UAC 为「始终通知」时每次安装会弹一次确认；把 DSH 本身以管理员身份运行则不会再弹。
+Edge 走它自带的更新服务：winget 目录里的 `Microsoft.Edge` 是企业版 MSI，与本机消费版的
+安装技术不匹配（`0x8A15008E`），winget 会直接拒绝。
+
 > macOS 的 Homebrew 路径是按 Homebrew 官方 CLI 行为实现的，识别与解析逻辑有单测覆盖；
 > 但本插件主要在 Windows 上开发，macOS 上的安装/更新没有真机验证过，遇到问题请开 Issue。
 

package/RELEASING.md

@@ -56,6 +56,19 @@ gh release create v<version> dsh-app-updater.tgz \
   - dshopen.org → https://github.com/polang233/dsh-plugin-index/issues/new?template=plugin-add.yml
   - awesome-dsh-plugin → 向仓库提 PR，新增 `data/plugins/<owner>__<repo>.yml`（见其 contributing.md）
 
+### 刚发版时别人可能装到旧版本
+
+pnpm 默认有 `minimumReleaseAge`（新发布的包先观察一段时间才参与解析）。profile 里若没写
+`minimumReleaseAge: 0`，`dsh plugin add <包名>` 在发版后的一段时间内可能仍解析到上一个版本：
+
+```bash
+# 立刻拿到刚发布的版本：显式指定版本号
+dsh plugin --profile web add dsh-app-updater@<version>
+```
+
+这不是包的问题，是消费端的供应链策略；等宽限期过去后不带版本号也会解析到新版。
+（排查时看 profile 的 `pnpm-workspace.yaml`：`minimumReleaseAge` 与 `minimumReleaseAgeExclude`。）
+
 ## 6. 本地开发时的桌面端安装
 
 Electron 托管的 `desktop` profile 不接受 `dsh plugin` 写入。做法是在

package/lib/client.js

@@ -52,6 +52,11 @@ window.__ModuleLoader__.load({
         label: "按本机架构安装包",
         hint: "按当前系统与芯片（Windows ARM64 / x64、Apple Silicon / Intel）挑选对应安装包",
       },
+      {
+        key: "autoElevate",
+        label: "自动提权安装",
+        hint: "需要管理员的安装包（MSI、写入 Program Files）改由管理员上下文执行；UAC 开启时每次安装会弹一次确认",
+      },
       {
         key: "hashFallbackUpgrade",
         label: "下载失败时回退 winget",

package/lib/elevate.js

@@ -0,0 +1,205 @@
+/**
+ * Windows 提权执行。
+ *
+ * 为什么需要它：winget 目录里的「官网全量包」有一大半是**机器级**安装 —— MSI 要
+ * 写 HKLM / Program Files，安装器要往 Program Files 落文件。进程没有管理员令牌
+ * 时有两种失败方式：
+ *  1) MSI 直接失败（msiexec 返回 1603，MSI 日志里是 Error 1925「权限不足」）；
+ *  2) 安装器**静默退出 0 却什么都没装**（实测 Logitech G HUB）。
+ * 第 2 种最坑：只看退出码就会误报「更新成功」，所以安装之后必须复核版本
+ * （见 engine.js 的 verifyInstalled）。
+ *
+ * Windows 的进程令牌创建后无法原地提升，因此这里把**一条命令**写进临时
+ * PowerShell 助手脚本，用 `Start-Process -Verb RunAs` 在提权副本里执行，再把
+ * 退出码与输出回传到文件后读回。两个脚本都写成 UTF-8 **带 BOM**：Windows
+ * PowerShell 5.1 读 .ps1 时若无 BOM 会按本地代码页解码，中文路径会乱。
+ */
+
+import { existsSync } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runProcess } from "./proc.js";
+
+const PS_PROBE_TIMEOUT_MS = 20000;
+
+/** Windows 取消提权的退出码（ERROR_CANCELLED）。 */
+export const ELEVATION_CANCELLED = 1223;
+
+/** PowerShell 单引号字面量：内部的 `'` 要写成 `''`。 */
+export function psQuote(value) {
+  return `'${String(value == null ? "" : value).replace(/'/g, "''")}'`;
+}
+
+/** Windows PowerShell 5.1 的绝对路径。 */
+export function powershellPath(env = process.env) {
+  const root = env.SystemRoot || env.windir || "C:\\Windows";
+  return join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+}
+
+/** 本机是否有可用的 PowerShell（没有它就无法提权）。 */
+export function elevationAvailable(env = process.env) {
+  try {
+    return existsSync(powershellPath(env));
+  } catch {
+    return false;
+  }
+}
+
+let cachedElevated = null;
+
+/** 清掉「是否已提权」的缓存（单元测试与提权后复核用）。 */
+export function resetElevationCache() {
+  cachedElevated = null;
+}
+
+/**
+ * 当前进程是否在管理员上下文里。
+ * 非 Windows 平台按 uid==0 判断（macOS 的 brew 永远不需要提权）。
+ */
+export async function isElevated(opts = {}) {
+  if (cachedElevated !== null && !opts.refresh) return cachedElevated;
+  if (process.platform !== "win32") {
+    cachedElevated = typeof process.getuid === "function" ? process.getuid() === 0 : true;
+    return cachedElevated;
+  }
+  if (!elevationAvailable()) {
+    cachedElevated = false;
+    return cachedElevated;
+  }
+  const res = await runProcess(
+    powershellPath(),
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      "[Security.Principal.WindowsPrincipal]::new([Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)",
+    ],
+    { timeoutMs: PS_PROBE_TIMEOUT_MS, signal: opts.signal }
+  );
+  cachedElevated = res.ok && /true/i.test(res.stdout);
+  return cachedElevated;
+}
+
+function stripBom(text) {
+  return String(text || "").replace(/^\ufeff/, "");
+}
+
+/**
+ * 在提权副本里执行一条命令。
+ *
+ * 返回结构与 proc.js 的 runProcess 一致（外加 cancelled），因此调用方可以
+ * 无差别地把它当成「另一个 runProcess」。
+ *
+ * @param {string} exe 绝对路径
+ * @param {string[]} args 参数数组
+ * @param {{ timeoutMs?: number, signal?: AbortSignal }} [opts]
+ * @returns {Promise<{ok:boolean, code:number|null, stdout:string, stderr:string, timedOut:boolean, spawnError:string|null, cancelled:boolean}>}
+ */
+export async function runElevated(exe, args, opts = {}) {
+  const timeoutMs = opts.timeoutMs || 60 * 60 * 1000;
+  const fail = (spawnError) => ({
+    ok: false,
+    code: null,
+    stdout: "",
+    stderr: "",
+    timedOut: false,
+    spawnError,
+    cancelled: false,
+  });
+
+  if (process.platform !== "win32") return fail("非 Windows 平台不支持提权执行");
+  if (!elevationAvailable()) return fail("未找到 powershell.exe，无法提权执行");
+
+  const ps = powershellPath();
+  const dir = await mkdtemp(join(tmpdir(), "dsh-app-updater-elev-"));
+  const outFile = join(dir, "out.txt");
+  const codeFile = join(dir, "code.txt");
+  const helperFile = join(dir, "helper.ps1");
+  const launchFile = join(dir, "launch.ps1");
+
+  const helper = [
+    "$ErrorActionPreference = 'Continue'",
+    "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8",
+    "$OutputEncoding = [System.Text.Encoding]::UTF8",
+    `$exe = ${psQuote(exe)}`,
+    `$argv = @(${(args || []).map(psQuote).join(", ")})`,
+    `& $exe @argv 2>&1 | Out-File -FilePath ${psQuote(outFile)} -Encoding UTF8`,
+    "$code = $LASTEXITCODE",
+    "if ($null -eq $code) { $code = 0 }",
+    `Set-Content -Path ${psQuote(codeFile)} -Value $code -Encoding ASCII`,
+    "exit $code",
+    "",
+  ].join("\r\n");
+
+  // 启动器只负责「把助手脚本以管理员身份跑起来并把退出码带回来」。
+  const launch = [
+    "$ErrorActionPreference = 'Stop'",
+    "try {",
+    `  $p = Start-Process -FilePath ${psQuote(ps)} -ArgumentList @('-NoProfile','-NonInteractive','-ExecutionPolicy','Bypass','-File', ${psQuote(helperFile)}) -Verb RunAs -WindowStyle Hidden -Wait -PassThru`,
+    `} catch { exit ${ELEVATION_CANCELLED} }`,
+    `if ($null -eq $p) { exit ${ELEVATION_CANCELLED} }`,
+    "exit $p.ExitCode",
+    "",
+  ].join("\r\n");
+
+  try {
+    await writeFile(helperFile, `\ufeff${helper}`, "utf8");
+    await writeFile(launchFile, `\ufeff${launch}`, "utf8");
+  } catch (err) {
+    await rm(dir, { recursive: true, force: true }).catch(() => {});
+    return fail(String((err && err.message) || err));
+  }
+
+  const res = await runProcess(
+    ps,
+    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", launchFile],
+    { timeoutMs, signal: opts.signal }
+  );
+
+  let stdout = "";
+  try {
+    stdout = stripBom(await readFile(outFile, "utf8"));
+  } catch {
+    // 安装器没有产出任何输出：正常（GUI 安装包），失败原因由退出码与 MSI 日志给
+  }
+
+  let code = res.code;
+  let reported = false;
+  try {
+    const raw = stripBom(await readFile(codeFile, "utf8")).trim();
+    if (/^-?\d+$/.test(raw)) {
+      code = Number(raw);
+      reported = true;
+    }
+  } catch {
+    // 提权副本没能跑到写退出码那一步
+  }
+
+  // 超时时提权副本可能还在跑（安装器），保留临时目录不删，避免动到正在执行的脚本
+  if (!res.timedOut) {
+    await rm(dir, { recursive: true, force: true }).catch(() => {});
+  }
+
+  const cancelled = res.code === ELEVATION_CANCELLED || code === ELEVATION_CANCELLED;
+  const spawnError = res.spawnError
+    ? res.spawnError
+    : cancelled
+      ? "提权被拒绝（UAC 被取消）"
+      : !reported && !res.timedOut && code !== 0
+        ? "提权副本未能报告退出码（可能被 UAC 拒绝）"
+        : null;
+
+  return {
+    ok: !res.timedOut && !spawnError && code === 0,
+    code,
+    stdout,
+    stderr: "",
+    timedOut: res.timedOut,
+    spawnError,
+    cancelled,
+  };
+}

package/lib/engine.js

@@ -10,11 +10,12 @@
  */
 
 import { mkdir, readdir, stat, readFile, rm } from "node:fs/promises";
-import { lstatSync } from "node:fs";
+import { existsSync, lstatSync } from "node:fs";
 import { join, basename, isAbsolute } from "node:path";
 import { homedir } from "node:os";
 
 import { runProcess, outputText } from "./proc.js";
+import { elevationAvailable, isElevated, runElevated } from "./elevate.js";
 import {
   findWinget,
   runWinget,
@@ -426,6 +427,219 @@ export async function scanApps({ settings, log, signal }) {
   };
 }
 
+/* ------------------------------------------------------------------ *
+ * 提权、复核与「自带更新服务」
+ * ------------------------------------------------------------------ */
+
+/**
+ * winget 报「清单里没有可用安装包」一类错误（本机架构没有对应安装包）。
+ * 中文输出是「找不到适用的安装程序」，英文是 “No applicable installer found”。
+ *
+ * 这类失败必须退回「不限架构」再来一次：虎牙直播（Huya.Huya）的清单里只有
+ * 一个不标架构的通用 exe，带上 `--architecture x64` 就永远找不到。
+ */
+export function isArchNotFoundError(text) {
+  const raw = String(text || "");
+  if (!raw) return false;
+  return /architecture|架构|applicable installer|not applicable|找不到适用|没有适用/i.test(raw);
+}
+
+/** 安装器退出码 → 人话。输出为空时兜底；MSI 的真实原因在它自己的日志里。 */
+export function explainInstallerExitCode(code, text) {
+  const first = firstLine(text);
+  if (first) return first;
+  const map = {
+    1603: "安装程序返回 1603（安装失败：常见原因是权限不足、文件被占用或已装其它版本；MSI 详情见日志）",
+    1619: "安装程序返回 1619（安装包无法打开）",
+    1620: "安装程序返回 1620（安装包损坏或不可读）",
+    1625: "安装程序返回 1625（被系统策略禁止）",
+    1638: "安装程序返回 1638（已安装其它版本）",
+    1730: "安装程序返回 1730（卸载/安装需要管理员权限）",
+  };
+  return map[code] || `安装程序退出码 ${code}`;
+}
+
+/**
+ * 判断一次更新是否真的生效。
+ *
+ * 只看安装器退出码是不够的：机器级安装包在没有管理员令牌时会**静默退出 0**
+ * 却什么都没装（实测 Logitech G HUB 2026.6.981214 → 目标 2026.7.992920，
+ * 退出码 0，Program Files 里的文件与 winget 报的版本都没有变化）。
+ * 所以拿「安装前版本 / 安装后版本 / 目标版本」三个值判断，判不出来才算失败。
+ *
+ * @returns {{changed: boolean, reason: string}}
+ */
+export function evaluateUpdateResult({ before, after, target }) {
+  const a = String(after == null ? "" : after).trim();
+  const b = String(before == null ? "" : before).trim();
+  const t = String(target == null ? "" : target).trim();
+  // winget 读不到已装版本（虎牙直播的卸载信息里就没有版本号）→ 无法复核：
+  // 既不能判生效也不能判失败，交给调用方按「已安装、未复核」处理。
+  if (!looksLikeVersion(a)) {
+    return {
+      changed: false,
+      unverifiable: true,
+      reason: a ? `winget 读不到已装版本（显示为 ${a}）` : "安装后读不到版本",
+    };
+  }
+  // 达到或超过目标版本 → 生效
+  if (t && !isNewer(t, a)) {
+    return { changed: true, reason: `版本已是 ${a}（目标 ${t}）` };
+  }
+  // 目标版本未知时，只能看它是否真的变新了
+  if (b && looksLikeVersion(b) && isNewer(a, b)) {
+    return { changed: true, reason: `版本从 ${b} 升到 ${a}` };
+  }
+  if (t) return { changed: false, reason: `版本没有变化（仍为 ${a}，目标 ${t}）` };
+  return { changed: false, reason: `版本没有变化（仍为 ${a}）` };
+}
+
+/** 可取消的等待。 */
+function delay(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal && signal.aborted) {
+      resolve();
+      return;
+    }
+    const finish = () => {
+      clearTimeout(timer);
+      if (signal) signal.removeEventListener("abort", finish);
+      resolve();
+    };
+    const timer = setTimeout(finish, ms);
+    if (signal) signal.addEventListener("abort", finish, { once: true });
+  });
+}
+
+/** 提权跑 winget：winget 自己的安装动作同样需要管理员令牌才能装机器级包。 */
+async function runWingetElevated(wingetPath, args, opts = {}) {
+  const res = await runElevated(wingetPath, args, { timeoutMs: opts.timeoutMs, signal: opts.signal });
+  return {
+    ok: res.ok,
+    code: res.code,
+    stdout: res.stdout || "",
+    stderr: "",
+    error: res.spawnError ? "spawn" : res.timedOut ? "timeout" : null,
+  };
+}
+
+/**
+ * 本轮的「目标版本」表：复核「到底升没升上去」的依据。
+ * 用一次 `winget upgrade --include-unknown` 拿全量（含已装版本为 Unknown 的应用）。
+ */
+async function fetchUpgradeTargets(wingetPath, ctx, signal) {
+  const map = new Map();
+  if (!wingetPath) return map;
+  try {
+    const res = await ctx.runWinget(
+      wingetPath,
+      ["upgrade", "--include-unknown", "--accept-source-agreements", "--disable-interactivity"],
+      { timeoutMs: 240000, signal }
+    );
+    if (res.ok) {
+      for (const row of parseUpgradeList(res.stdout)) {
+        const key = String(row.id || "").toLowerCase();
+        if (key && row.available) map.set(key, row.available);
+      }
+    }
+  } catch {
+    // 拿不到目标版本时退化为「只看版本有没有变化」
+  }
+  return map;
+}
+
+/**
+ * 自带更新服务的软件：winget 目录里给的是**企业版**安装包，与本机的消费版
+ * 安装技术不匹配，winget 会直接拒绝（0x8A15008E「安装技术与当前安装的版本
+ * 不同，请卸载包并安装较新版本」）。这类软件交给它自己的更新服务。
+ */
+const SELF_UPDATERS = new Map([
+  ["microsoft.edge", "edgeupdate"],
+  ["microsoft.edgewebview2runtime", "edgeupdate"],
+  ["microsoft.edgewebview", "edgeupdate"],
+]);
+
+/**
+ * 少数软件的更新不由安装包完成，而是由它自己的常驻更新器在**应用启动时**应用
+ * （实测 Logitech G HUB：更新包早就下载好躺在 %ProgramData%\LGHUB\next.json 指向的
+ * depots 里，安装器 `--silent` 和 winget upgrade 都退出 0 什么都不做，只有启动
+ * G HUB 本体后 current.json 才跳到新版本）。
+ *
+ * 插件承诺「不需要打开被检测的软件」，所以这里只给提示，不替用户启动 app。
+ */
+const UPDATE_HINTS = new Map([
+  [
+    "logitech.ghub",
+    "G HUB 的更新由它自己的更新器在「启动 G HUB」时应用：安装包与 winget 都可能退出 0 而不生效，手动打开一次 G HUB 即可完成升级（插件不会替你启动软件）",
+  ],
+  [
+    "microsoft.edge",
+    "Edge 由 EdgeUpdate 服务维护；该服务不可用时插件会退回安装官网全量包（企业版 MSI，提权执行）",
+  ],
+]);
+
+/** 这条应用有没有「安装之外的更新方式」提示。 */
+export function updateHintFor(id) {
+  return UPDATE_HINTS.get(String(id || "").toLowerCase()) || "";
+}
+
+/** 定位 Microsoft Edge 自带的更新服务。 */
+export function findEdgeUpdate(env = process.env) {
+  const roots = [
+    env["ProgramFiles(x86)"],
+    env.ProgramFiles,
+    "C:\\Program Files (x86)",
+    "C:\\Program Files",
+  ].filter(Boolean);
+  for (const root of roots) {
+    const file = join(root, "Microsoft", "EdgeUpdate", "MicrosoftEdgeUpdate.exe");
+    try {
+      if (existsSync(file)) return file;
+    } catch {
+      // 受保护目录读不到时继续找下一个
+    }
+  }
+  return null;
+}
+
+/**
+ * 触发自带更新服务（目前只有 Edge）。
+ * 它的退出码不代表版本已经就位（只是把任务交给服务），所以交给 verifyInstalled 轮询确认。
+ */
+async function runSelfUpdater(kind, log, signal, ctx) {
+  if (kind !== "edgeupdate") return { ok: false, error: "未知的自带更新方式" };
+  const exe = findEdgeUpdate();
+  if (!exe) return { ok: false, error: "未找到 MicrosoftEdgeUpdate.exe（Edge 自带更新服务）" };
+  log("info", "改用 Edge 自带更新服务（winget 目录里是企业版 MSI，与本机消费版 Edge 的安装技术不匹配）");
+  const res = await ctx.run(exe, ["/ua"], { timeoutMs: 30 * 60 * 1000, signal });
+  if (res.spawnError) return { ok: false, error: res.spawnError };
+  if (res.timedOut) return { ok: false, error: "Edge 自带更新服务超时" };
+  return { ok: true, note: "已交给 Microsoft Edge 更新服务，等待版本就位" };
+}
+
+/**
+ * 安装后复核：读已装版本，与目标/安装前版本比对，必要时轮询等待
+ * （Edge 这类自带更新服务不是同步生效的）。
+ */
+async function verifyInstalled({ wingetPath, id, before, target, signal, log, attempts = 1, delayMs = 15000 }) {
+  let version = "";
+  let verdict = { changed: false, reason: "尚未复核" };
+  const rounds = Math.max(1, attempts);
+  for (let i = 0; i < rounds; i += 1) {
+    if (signal && signal.aborted) break;
+    version = await readInstalledVersion(wingetPath, id, signal);
+    verdict = evaluateUpdateResult({ before, after: version, target });
+    if (verdict.changed || verdict.unverifiable) return { ...verdict, version };
+    if (i + 1 < rounds) {
+      if (log && i === 0) {
+        log("info", `${id}：暂未读到新版本（${version || "未知"}），继续等待…`);
+      }
+      await delay(delayMs, signal);
+    }
+  }
+  return { ...verdict, version };
+}
+
 function firstLine(text) {
   const line = String(text || "").trim().split("\n")[0] || "";
   return line.slice(0, 200);
@@ -483,7 +697,7 @@ async function downloadInstaller(wingetPath, id, dir, log, signal, opts = {}) {
   if (!res.ok) {
     const err = classifyWingetError(text) || `winget download 退出码 ${res.code}`;
     // 指定架构失败（清单里没有这一架构的安装包）时，退回让 winget 自己挑，并如实记录
-    if (archFlag && /architecture|no applicable installer|not applicable|没有适用/i.test(text)) {
+    if (archFlag && isArchNotFoundError(text)) {
       log("warn", `${id}：清单里没有 ${archFlag} 架构的安装包，改为自动匹配`);
       return downloadInstaller(wingetPath, id, dir, log, signal, { ...opts, matchArch: false });
     }
@@ -531,48 +745,73 @@ async function downloadInstaller(wingetPath, id, dir, log, signal, opts = {}) {
 }
 
 /** 执行安装包（静默）。 */
-async function runInstaller(installer, info, log, signal) {
+async function runInstaller(installer, info, log, signal, ctx = {}) {
   const ext = String(installer).toLowerCase();
   const isMsi = ext.endsWith(".msi");
+  const run = ctx.run || runProcess;
   const args = resolveInstallArgs(info, installer);
   const exe = isMsi ? join(process.env.SystemRoot || "C:\\Windows", "System32", "msiexec.exe") : installer;
-  const finalArgs = isMsi ? ["/i", installer, ...args] : args;
+  // 安装失败时唯一能说明原因的现场就是 MSI 自己的日志（Error 1925 / 1603 …），
+  // 所以顺手开一份；日志路径由调用方提供一个可写目录（临时目录里没有空格）。
+  const msiLog = isMsi && ctx.scratchDir
+    ? join(ctx.scratchDir, `${basename(installer).replace(/[^\w.-]+/g, "_")}.msi.log`)
+    : "";
+  const finalArgs = isMsi ? ["/i", installer, ...args, ...(msiLog ? ["/l*v", msiLog] : [])] : args;
   log("info", `静默安装：${basename(installer)} ${finalArgs.join(" ")}`.trim());
-  const res = await runProcess(exe, finalArgs, { timeoutMs: 60 * 60 * 1000, signal });
+  if (ctx.elevated) log("info", "安装步骤在管理员上下文中执行（自动提权）");
+  const res = await run(exe, finalArgs, { timeoutMs: 60 * 60 * 1000, signal });
   const text = outputText(res);
   if (res.spawnError) return { ok: false, error: res.spawnError, code: null };
   if (res.timedOut) return { ok: false, error: "安装超时（60 分钟）", code: null };
   if (res.code !== 0) {
     // 3010 = 需要重启，属成功
     if (res.code === 3010) return { ok: true, code: res.code, note: "安装完成，需重启生效" };
-    return { ok: false, error: firstLine(text) || `安装程序退出码 ${res.code}`, code: res.code };
+    const detail = msiLog && existsSync(msiLog) ? `；MSI 日志：${msiLog}` : "";
+    return { ok: false, error: explainInstallerExitCode(res.code, text) + detail, code: res.code };
   }
   return { ok: true, code: 0 };
 }
 
-/** 用 winget upgrade 兜底（同样是官网全量包，安装由 winget 执行）。 */
+/**
+ * 用 winget upgrade 兜底（同样是官网全量包，安装由 winget 执行）。
+ *
+ * 两道修正：
+ *  1) 带上 `--include-unknown`：已装版本被 winget 读成 Unknown 的应用（虎牙直播）
+ *     不带它就直接「目录里没有适用的更新」；
+ *  2) 带架构过滤而失败时退回不限架构再试一次（清单里只有通用 exe 的应用）。
+ */
 async function wingetUpgradeFallback(wingetPath, id, log, signal, opts = {}) {
   const env = opts.env || currentEnvironment();
+  const run = opts.run || runWinget;
   const archFlag = opts.matchArch === false ? "" : env.wingetArch || "";
-  log("warn", `改用 winget upgrade 兜底：${id}${archFlag ? "（--architecture " + archFlag + "）" : ""}`);
-  const args = [
-    "upgrade",
-    "--id",
-    id,
-    "--exact",
-    "--silent",
-    "--accept-package-agreements",
-    "--accept-source-agreements",
-    "--disable-interactivity",
-  ];
-  if (archFlag) args.push("--architecture", archFlag);
-  const res = await runWinget(wingetPath, args, { timeoutMs: 60 * 60 * 1000, signal });
-  const text = outputText(res);
+
+  const attempt = async (flag) => {
+    log("warn", `改用 winget upgrade 兜底：${id}（${flag ? "--architecture " + flag : "不限架构"}）`);
+    const args = [
+      "upgrade",
+      "--id",
+      id,
+      "--exact",
+      "--silent",
+      "--include-unknown",
+      "--accept-package-agreements",
+      "--accept-source-agreements",
+      "--disable-interactivity",
+    ];
+    if (flag) args.push("--architecture", flag);
+    const res = await run(wingetPath, args, { timeoutMs: 60 * 60 * 1000, signal });
+    return { res, text: outputText(res) };
+  };
+
+  let { res, text } = await attempt(archFlag);
+  if (!res.ok && archFlag && isArchNotFoundError(text)) {
+    // 清单里没有本机架构的安装包 → 交回 winget 自己挑
+    ({ res, text } = await attempt(""));
+  }
   if (res.ok) return { ok: true };
   const code = res.code;
-  if (code === 3010 || (code >>> 0) === 0x8a15002b) {
-    return code === 3010 ? { ok: true, note: "安装完成，需重启生效" } : { ok: false, error: "目录里没有适用的更新" };
-  }
+  if (code === 3010) return { ok: true, note: "安装完成，需重启生效" };
+  if ((code >>> 0) === 0x8a15002b) return { ok: false, error: "目录里没有适用的更新" };
   return { ok: false, error: classifyWingetError(text) || `winget upgrade 退出码 ${code}` };
 }
 
@@ -613,7 +852,7 @@ function classifyWingetError(text) {
  * @param {(patch: object) => void} p.onProgress 进度回调（写进 state.update）
  * @param {AbortSignal} p.signal
  */
-export async function runUpdates({ ids, settings, log, onProgress, signal }) {
+export async function runUpdates({ ids, settings, log, onProgress, signal, plan = [] }) {
   const env = currentEnvironment();
   const matchArch = settings.matchSystemArch !== false;
 
@@ -625,9 +864,35 @@ export async function runUpdates({ ids, settings, log, onProgress, signal }) {
   const dir = resolveDownloadDir(settings);
   const results = [];
   const queue = [...new Set(ids.filter(Boolean))];
+  const planById = new Map(
+    (Array.isArray(plan) ? plan : [])
+      .map((item) => [String((item && item.id) || "").toLowerCase(), item])
+      .filter(([key]) => key)
+  );
+
+  // 提权：机器级安装（MSI / 写 Program Files）需要管理员令牌，而进程令牌创建后无法
+  // 原地提升，所以安装类命令交给提权副本执行（lib/elevate.js）。读版本、下载都不需要。
+  const autoElevate = settings.autoElevate !== false;
+  const elevatedNow = env.family === "windows" ? await isElevated({ signal }) : true;
+  const useElevation = env.family === "windows" && autoElevate && !elevatedNow && elevationAvailable();
+  const ctx = {
+    run: (exe, args, o) => (useElevation ? runElevated(exe, args, o) : runProcess(exe, args, o)),
+    runWinget: (exe, args, o) => (useElevation ? runWingetElevated(exe, args, o) : runWinget(exe, args, o)),
+    elevated: useElevation,
+    scratchDir: dir,
+  };
 
   onProgress({ running: true, total: queue.length, done: 0, current: null, results: [], error: null, startedAt: Date.now() });
   log("info", `开始更新 ${queue.length} 个应用（${describeEnvironment(env)}，按架构匹配：${matchArch ? "是" : "否"}）`);
+  if (env.family === "windows") {
+    if (elevatedNow) log("info", "当前进程已具备管理员权限");
+    else if (useElevation) log("info", "当前进程没有管理员权限：需要管理员的安装步骤会自动提权执行");
+    else if (autoElevate) log("warn", "当前进程没有管理员权限，且找不到 powershell.exe：无法自动提权，机器级安装会失败");
+    else log("warn", "当前进程没有管理员权限，且已关闭「自动提权安装」：机器级安装会失败（MSI 报 1925、安装器静默退出 0）");
+  }
+
+  // 「目标版本」表：安装后复核「到底升没升上去」的依据
+  const targets = await fetchUpgradeTargets(wingetPath, ctx, signal);
 
   let index = 0;
   for (const id of queue) {
@@ -641,11 +906,53 @@ export async function runUpdates({ ids, settings, log, onProgress, signal }) {
     log("info", `（${index}/${queue.length}）开始处理 ${id}`);
 
     const startedAt = Date.now();
+    const target = targets.get(id.toLowerCase()) || "";
+    const before = (planById.get(id.toLowerCase()) || {}).version || "";
     let entry = { id, ok: false, error: null, installer: null, fromCache: false, note: null, verified: null, durationMs: 0 };
 
     try {
+      const selfUpdater = SELF_UPDATERS.get(id.toLowerCase());
+      let settled = false;
+
       if (!wingetPath) {
         entry.error = "未找到 winget，无法下载官网安装包";
+      } else if (selfUpdater && settings.useSelfUpdater !== false && !settings.dryRun) {
+        // 先让软件自带的更新服务试一次；没生效就退回官网全量安装包。
+        // Edge 的实测：EdgeUpdate 服务坏掉时 /ua 直接 0x80070002，而 winget 目录里的
+        // 官方安装包（企业版 MSI）在提权下能正常把 Edge 装到目标版本 —— winget 自己
+        // 拒绝执行只是因为「安装技术不同」这条策略。
+        entry.selfUpdater = selfUpdater;
+        const r = await runSelfUpdater(selfUpdater, log, signal, ctx);
+        entry.note = r.note || null;
+        if (r.ok) {
+          const check = await verifyInstalled({
+            wingetPath,
+            id,
+            before,
+            target,
+            signal,
+            log,
+            attempts: 12,
+            delayMs: 15000,
+          });
+          entry.verified = check.version || null;
+          if (check.changed || check.unverifiable) {
+            settled = true;
+            entry.ok = true;
+            entry.note = `${entry.note ? entry.note + "；" : ""}${check.changed ? "复核通过：" : "未复核："}${check.reason}`;
+            log(check.changed ? "success" : "warn", `${id} ${check.changed ? "更新完成" : "已安装（未复核）"}，${check.reason}`);
+          } else {
+            log("warn", `${id}：自带更新服务没有生效（${check.reason}），改用官网全量安装包`);
+          }
+        } else {
+          log("warn", `${id}：${r.error}，改用官网全量安装包`);
+        }
+      }
+
+      if (settled) {
+        // 自带更新服务已经完成并复核过
+      } else if (entry.error || !wingetPath || signal.aborted) {
+        log("error", `${id} 更新失败：${entry.error}`);
       } else {
         const dl = await downloadInstaller(wingetPath, id, dir, log, signal, { env, matchArch });
         if (!dl.ok) {
@@ -653,15 +960,18 @@ export async function runUpdates({ ids, settings, log, onProgress, signal }) {
         } else if (settings.dryRun) {
           // 演练模式：照常从官网下载全量安装包并落盘，但不执行安装。
           entry.installer = dl.installer;
+          entry.manifest = dl.manifest || null;
           entry.ok = true;
           entry.dryRun = true;
           entry.note = "演练模式：已下载官网全量安装包，未执行安装";
           log("warn", `${id}：演练模式，已下载 ${basename(dl.installer)}，跳过安装`);
         } else {
           entry.installer = dl.installer;
-          const inst = await runInstaller(dl.installer, dl.info, log, signal);
+          entry.manifest = dl.manifest || null;
+          const inst = await runInstaller(dl.installer, dl.info, log, signal, ctx);
           if (inst.ok) {
             entry.ok = true;
+            entry.installOk = true;
             entry.note = inst.note || null;
           } else {
             entry.error = inst.error;
@@ -671,27 +981,50 @@ export async function runUpdates({ ids, settings, log, onProgress, signal }) {
         // 下载失败或安装失败 → winget upgrade 兜底（同样是官网全量包）
         if (!entry.ok && !entry.dryRun && settings.hashFallbackUpgrade !== false && !signal.aborted) {
           log("warn", `${id}：${entry.error}，尝试 winget upgrade 兜底`);
-          const fb = await wingetUpgradeFallback(wingetPath, id, log, signal, { env, matchArch });
+          const fb = await wingetUpgradeFallback(wingetPath, id, log, signal, { env, matchArch, run: ctx.runWinget });
           if (fb.ok) {
             entry.ok = true;
+            entry.installOk = true;
             entry.error = null;
             entry.note = fb.note || "已通过 winget 安装官网全量包";
           } else {
             entry.error = `${entry.error}；兜底失败：${fb.error}`;
           }
         }
-      }
 
-      if (entry.ok) {
-        const version = await readInstalledVersion(wingetPath, id, signal);
-        if (version) {
-          entry.verified = version;
-          log("success", `${id} 更新完成，当前版本 ${version}`);
-        } else {
+        // 复核：退出码 0 ≠ 装上了。机器级安装包在没有管理员令牌时会静默退出 0 却什么都没装。
+        if (entry.ok && !entry.dryRun && !signal.aborted) {
+          const check = await verifyInstalled({
+            wingetPath,
+            id,
+            before,
+            target,
+            signal,
+            log,
+            attempts: 4,
+            delayMs: 15000,
+          });
+          entry.verified = check.version || null;
+          if (check.changed) {
+            entry.note = `${entry.note ? entry.note + "；" : ""}复核通过：${check.reason}`;
+            log("success", `${id} 更新完成，${check.reason}`);
+          } else if (check.unverifiable) {
+            // 读不到已装版本（卸载信息里没有版本号）：按「已安装、未复核」处理，不能算失败
+            entry.note = `${entry.note ? entry.note + "；" : ""}未复核：${check.reason}`;
+            log("warn", `${id} 已安装，但无法复核版本：${check.reason}`);
+          } else {
+            entry.ok = false;
+            const hint = updateHintFor(id);
+            entry.error = `安装报告成功，但没有生效：${check.reason}${hint ? `。${hint}` : ""}`;
+            log("error", `${id} 更新失败：${entry.error}`);
+          }
+        } else if (entry.ok && entry.dryRun) {
+          // 演练模式没有真正安装，不做版本复核
+        } else if (entry.ok) {
           log("success", `${id} 更新完成`);
+        } else {
+          log("error", `${id} 更新失败：${entry.error}`);
         }
-      } else {
-        log("error", `${id} 更新失败：${entry.error}`);
       }
     } catch (err) {
       entry.ok = false;
@@ -702,6 +1035,8 @@ export async function runUpdates({ ids, settings, log, onProgress, signal }) {
     entry.durationMs = Date.now() - startedAt;
     if (!settings.keepInstallers && entry.installer) {
       rm(entry.installer, { force: true }).catch(() => {});
+      // winget download 会同时落一份 .yaml 清单，别让它留在下载目录里
+      if (entry.manifest) rm(entry.manifest, { force: true }).catch(() => {});
     }
     results.push(entry);
     onProgress({ running: true, total: queue.length, done: index, current: null, results });

package/lib/index.js

@@ -79,12 +79,62 @@ function readJsonBody(req) {
   });
 }
 
-/** 写操作闸门：loopback + confirm:true。 */
-async function writeGate(req, res) {
-  if (!isLoopback(req)) {
-    json(res, 403, { ok: false, error: "只接受本机请求（loopback）" });
-    return null;
+/** 请求是否携带了 DSH 连接凭据（浏览器会话 Cookie 或 API Cookie）。 */
+export function hasConnectionCredentials(req) {
+  const h = (req && req.headers) || {};
+  return Boolean(h.cookie || h.authorization);
+}
+
+/**
+ * connection 准入（宿主信任边界）。
+ *
+ * DSH 的 `connection` 服务负责插件 HTTP 路由的信任校验：`admit(request)` 先做
+ * Host/Origin 校验，再做浏览器会话 / API 认证，返回本次调用对应的 Peer，或用
+ * `401`（未认证）/`403`（不可信来源）拒绝 —— 宿主自己的 `/api` 路由用的就是它。
+ *
+ * 退回策略（只有一条，且完全不涉及凭据）：宿主没有 `connection` 服务，
+ * 或者请求**没有携带任何连接凭据**、来自回环地址时，按旧的「回环」规则放行，
+ * 并在响应头标注 `X-DSH-Admission: loopback-legacy`。
+ * 带凭据的请求一律以 admission 的结果为准；非回环请求一律拒绝。
+ *
+ * @returns {boolean} 已放行 true；已写出拒绝响应 false
+ */
+export function admissionGate(req, res, connection) {
+  const loopback = isLoopback(req);
+  if (connection && typeof connection.admit === "function") {
+    let admission;
+    try {
+      admission = connection.admit(req);
+    } catch (err) {
+      json(res, 500, { ok: false, error: `连接准入失败：${String((err && err.message) || err)}` });
+      return false;
+    }
+    if (!admission || typeof admission.rejection !== "number") return true;
+    if (admission.rejection === 401 && loopback && !hasConnectionCredentials(req)) {
+      // 宿主自己的载体（Electron 经 IPC 桥接的 fetch）与本机脚本都不带 Cookie，
+      // 没有可核验的凭据，只能按回环信任放行 —— 与接入准入之前的行为一致。
+      if (typeof res.setHeader === "function") res.setHeader("X-DSH-Admission", "loopback-legacy");
+      return true;
+    }
+    res.writeHead(admission.rejection, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end(admission.rejection === 401 ? "unauthorized" : "forbidden");
+    return false;
+  }
+  if (!loopback) {
+    json(res, 403, { ok: false, error: "只接受本机请求（loopback）：当前宿主没有可用的 connection 准入服务" });
+    return false;
   }
+  if (typeof res.setHeader === "function") res.setHeader("X-DSH-Admission", "loopback-legacy");
+  return true;
+}
+
+/**
+ * 写操作闸门：`confirm:true`。
+ *
+ * 来源校验已经由 `register()` 里的 connection 准入做过（见 admissionGate），
+ * 这里只负责「这次写入是用户显式确认过的」。
+ */
+async function writeGate(req, res) {
   const body = await readJsonBody(req);
   if (body.tooLarge) {
     json(res, 413, { ok: false, error: "请求体过大" });
@@ -247,6 +297,9 @@ async function startUpdate(ids) {
     try {
       await runUpdates({
         ids: list,
+        // 把界面刚扫描出来的「已装版本 / 目标版本」一并带过去：安装后的复核要用它
+        // 判断这次更新到底有没有真的生效（只看退出码会把「静默退出 0 却什么都没装」误报成功）
+        plan: (store.state.apps.items || []).filter((it) => list.includes(it.id)),
         settings: store.state.settings,
         log: (level, text) => store.log(level, text),
         signal: abort.signal,
@@ -297,10 +350,33 @@ export default {
 
     ctx.inject(["webServer"], (webCtx) => {
       const webServer = webCtx.webServer;
+
+      // connection 准入：宿主提供的信任边界（Host/Origin 校验 + 浏览器/API 认证）。
+      // 它在宿主没有 Web 载体时不存在，此时 admissionGate 退回旧的「回环」检查。
+      let connection = null;
+      ctx.inject(["connection"], (connCtx) => {
+        connection = connCtx.connection;
+        return () => {
+          connection = null;
+        };
+      });
       const routes = [];
 
+      /**
+       * 注册一条路由：请求先过 connection 准入（见 admissionGate），再进业务处理。
+       * 写接口另有 `confirm:true` 闸门（writeGate）。
+       */
       const register = (path, handler) => {
-        routes.push(webServer.register({ kind: "exact", path: `${PREFIX}${path}`, handler }));
+        routes.push(
+          webServer.register({
+            kind: "exact",
+            path: `${PREFIX}${path}`,
+            handler: (req, res) => {
+              if (!admissionGate(req, res, connection)) return;
+              return handler(req, res);
+            },
+          })
+        );
       };
 
       register("/state.json", async (req, res) => {

package/lib/state.js

@@ -32,6 +32,8 @@ export function defaultSettings() {
     dryRun: false,
     // 按本机架构（Windows ARM64 / x64、Apple Silicon / Intel）挑选安装包
     matchSystemArch: true,
+    // 需要管理员的安装包（MSI / 写入 Program Files）改用管理员上下文执行
+    autoElevate: true,
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-app-updater",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "description": "App Updater for DeepSeek Harness: detect every installed app that has a newer version and update it with one click by downloading the vendor's full installer from its official website and installing it silently — without launching the app. Windows (winget) and macOS (Homebrew), architecture-aware (ARM64 / x64). · 检测本机所有已安装应用是否有新版本，并从各自官网下载全量安装包一键静默更新（不需要打开被检测的软件）；自动识别 Windows / macOS 与 ARM64 / x64 架构，按架构下载对应安装包。",
   "license": "MIT",

package/test/render.mjs

@@ -359,7 +359,7 @@ tree = rt.render();
 group("设置面板与列宽手柄");
 ok(byClass(tree, "appupd-panel").length === 1, "渲染出插件设置面板");
 const switches = byClass(tree, "appupd-switch");
-ok(switches.length === 6, "渲染出 6 个设置开关", switches.length);
+ok(switches.length === 7, "渲染出 7 个设置开关（新增自动提权）", switches.length);
 ok(byClass(tree, "appupd-grip").length === 4, "渲染出 4 个列宽拖拽手柄", byClass(tree, "appupd-grip").length);
 const ths = walk(tree).filter((n) => n.type === "th");
 ok(ths.length === 6, "表头 6 列", ths.length);

package/test/unit.mjs

@@ -18,7 +18,9 @@ import {
   sliceByWidth,
 } from "../lib/winget.js";
 import { compareVersions, isNewer, looksLikeVersion, splitVersion } from "../lib/version.js";
-import { parseInstallerManifest, splitSwitchArgs, defaultSilentArgs, resolveInstallArgs, parseBrewCaskVersions, parseBrewOutdated, findBrew } from "../lib/engine.js";
+import { parseInstallerManifest, splitSwitchArgs, defaultSilentArgs, resolveInstallArgs, parseBrewCaskVersions, parseBrewOutdated, findBrew, isArchNotFoundError, explainInstallerExitCode, evaluateUpdateResult, findEdgeUpdate, updateHintFor } from "../lib/engine.js";
+import { psQuote, ELEVATION_CANCELLED } from "../lib/elevate.js";
+import { admissionGate, hasConnectionCredentials } from "../lib/index.js";
 import {
   detectEnvironment,
   describeEnvironment,
@@ -244,6 +246,102 @@ ok(outdated.get("visual-studio-code") === "1.95.0" && outdated.get("iterm2") ===
 ok(parseBrewOutdated("not json").size === 0, "坏 JSON 不抛错");
 ok(findBrew({ HOMEBREW_PREFIX: "/nonexistent-prefix-for-test" }) === null, "找不到 brew 时返回 null");
 
+/* ---------------- 提权与安装复核 ---------------- */
+group("提权执行（PowerShell 助手）");
+ok(psQuote("C:\\Program Files\\a.exe") === "'C:\\Program Files\\a.exe'", "psQuote 保留 Windows 路径");
+ok(psQuote("it's") === "'it''s'", "psQuote 转义单引号");
+ok(psQuote(null) === "''", "psQuote 处理 null");
+ok(ELEVATION_CANCELLED === 1223, "UAC 被取消的退出码是 1223");
+
+group("架构缺失错误识别（中英文都要认）");
+ok(isArchNotFoundError("找不到适用的安装程序;有关详细信息，请参阅日志。"), "中文「找不到适用」");
+ok(isArchNotFoundError("No applicable installer found"), "英文 No applicable installer");
+ok(!isArchNotFoundError("No package found matching input criteria"), "「找不到该包」不算架构问题");
+ok(!isArchNotFoundError(""), "空输出不算");
+ok(!isArchNotFoundError(null), "null 不算");
+
+group("安装后复核：退出码 0 不等于成功");
+ok(evaluateUpdateResult({ before: "2026.6.981214", after: "2026.6.981214", target: "2026.7.992920" }).changed === false, "G HUB：退出码 0、版本没变 → 判为失败");
+ok(evaluateUpdateResult({ before: "2026.6.981214", after: "2026.7.992920", target: "2026.7.992920" }).changed === true, "达到目标版本 → 成功");
+ok(evaluateUpdateResult({ before: "2026.6.981214", after: "2026.8.0", target: "2026.7.992920" }).changed === true, "超过目标版本 → 成功");
+ok(evaluateUpdateResult({ before: "Unknown", after: "Unknown", target: "7.5.0.0" }).unverifiable === true, "虎牙：读不到版本 → 无法复核（不能算失败）");
+ok(evaluateUpdateResult({ before: "1.0", after: "", target: "2.0" }).unverifiable === true, "空版本 → 无法复核");
+ok(evaluateUpdateResult({ before: "1.0.0", after: "1.2.0", target: "" }).changed === true, "目标未知但版本变新 → 成功");
+ok(evaluateUpdateResult({ before: "1.2.0", after: "1.2.0", target: "" }).changed === false, "目标未知且没变 → 失败");
+
+group("安装器退出码 → 人话");
+ok(explainInstallerExitCode(1603, "").includes("1603"), "1603 给出可读解释");
+ok(explainInstallerExitCode(1603, "first line\nsecond line") === "first line", "有输出时优先用输出的首行");
+ok(explainInstallerExitCode(9999, "") === "安装程序退出码 9999", "未知退出码原样透出");
+
+group("Edge 自带更新服务定位");
+const edgeUpdate = findEdgeUpdate();
+ok(edgeUpdate === null || /MicrosoftEdgeUpdate\.exe$/i.test(edgeUpdate), "返回绝对路径或 null");
+ok(updateHintFor("Logitech.GHUB").includes("启动 G HUB"), "G HUB 给出「启动应用才会应用更新」的提示");
+ok(updateHintFor("microsoft.edge").length > 0, "Edge 有提示");
+ok(updateHintFor("Some.Other") === "" && updateHintFor(null) === "", "未知应用没有提示");
+
+/* ---------------- connection 准入 ---------------- */
+function fakeRes() {
+  const res = { statusCode: 0, headers: {}, body: "" };
+  res.setHeader = (k, v) => {
+    res.headers[k] = v;
+  };
+  res.writeHead = (code, headers) => {
+    res.statusCode = code;
+    Object.assign(res.headers, headers || {});
+  };
+  res.end = (body) => {
+    res.body = String(body == null ? "" : body);
+  };
+  return res;
+}
+function fakeReq({ loopback = true, headers = {} } = {}) {
+  return { socket: { remoteAddress: loopback ? "127.0.0.1" : "10.0.0.5" }, headers };
+}
+
+group("connection 准入（市场审核要求）");
+ok(hasConnectionCredentials({ headers: { cookie: "dsh=x" } }) === true, "识别浏览器会话 Cookie");
+ok(hasConnectionCredentials({ headers: { authorization: "Bearer x" } }) === true, "识别 API Cookie/Authorization");
+ok(hasConnectionCredentials({ headers: {} }) === false, "没有凭据时返回 false");
+ok(admissionGate(fakeReq(), fakeRes(), null) === true, "宿主没有 connection 服务时，回环请求放行");
+{
+  const res = fakeRes();
+  ok(admissionGate(fakeReq({ loopback: false }), res, null) === false && res.statusCode === 403, "没有 connection 服务时，非回环请求 403");
+}
+{
+  const res = fakeRes();
+  const connection = { admit: () => ({ peer: { id: "peer-1" } }) };
+  ok(admissionGate(fakeReq(), res, connection) === true && res.statusCode === 0, "准入通过 → 放行且不写响应");
+}
+{
+  const res = fakeRes();
+  const connection = { admit: () => ({ rejection: 403 }) };
+  ok(admissionGate(fakeReq({ loopback: false }), res, connection) === false && res.statusCode === 403, "准入拒绝 403（不可信来源）→ 403");
+}
+{
+  const res = fakeRes();
+  const connection = { admit: () => ({ rejection: 401 }) };
+  ok(admissionGate(fakeReq({ headers: { cookie: "dsh=x" } }), res, connection) === false && res.statusCode === 401, "带凭据但未认证 → 401");
+}
+{
+  const res = fakeRes();
+  const connection = { admit: () => ({ rejection: 401 }) };
+  ok(
+    admissionGate(fakeReq(), res, connection) === true && res.headers["X-DSH-Admission"] === "loopback-legacy",
+    "无凭据的回环请求退回旧规则并标注响应头"
+  );
+}
+{
+  const res = fakeRes();
+  const connection = {
+    admit: () => {
+      throw new Error("carrier unavailable");
+    },
+  };
+  ok(admissionGate(fakeReq(), res, connection) === false && res.statusCode === 500, "准入抛错 → 500 而不是静默放行");
+}
+
 /* ---------------- 结果 ---------------- */
 console.log(`\n${failures === 0 ? "全部通过" : "存在失败"}：${checks - failures}/${checks}`);
 process.exit(failures === 0 ? 0 : 1);