dsh-app-updater 1.2.0 → 1.3.1

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 });