flower-trellis 0.6.8 → 0.6.9

package/src/lib/terminal-state.js

@@ -41,13 +41,13 @@ export function installWindowsTerminalInputRecovery(options = {}) {
 }
 
 /**
- * 在 Windows 交互完成页选择“退出”后恢复终端，并显式结束 CLI 进程。
+ * 在 Windows 命令完成或交互完成页选择“退出”后恢复终端，并显式结束 CLI 进程。
  *
  * node-pty 的 Windows ConPTY worker 在子进程自然退出后仍可能持有 MessagePort / Socket，
- * 因此不能只依赖 Node 事件循环自然清空。这里仅在用户已经选择退出时执行，并把实际退出
- * 延后到下一轮事件循环，让 Inquirer 完成当前输出清理。
+ * 因此不能只依赖 Node 事件循环自然清空。调用者必须确认顶层命令已结束或用户已经选择退出，
+ * 并把实际退出延后到下一轮事件循环，让 Inquirer 完成当前输出清理。
  *
- * @param {{platform?:string,input?:{isTTY?:boolean,isRaw?:boolean,setRawMode?:(value:boolean)=>unknown,pause?:()=>unknown},output?:{isTTY?:boolean,write:(value:string)=>unknown},schedule?:(callback:()=>void)=>unknown,exitProcess?:(code:number)=>unknown}} [options] 终端、调度器与退出函数测试注入
+ * @param {{platform?:string,input?:{isTTY?:boolean,isRaw?:boolean,setRawMode?:(value:boolean)=>unknown,pause?:()=>unknown},output?:{isTTY?:boolean,write:(value:string)=>unknown},schedule?:(callback:()=>void)=>unknown,exitProcess?:(code:number)=>unknown,exitCode?:number}} [options] 终端、调度器、退出码与退出函数测试注入
  * @returns {boolean} 是否安排了 Windows CLI 显式退出
  */
 export function scheduleWindowsTerminalExit(options = {}) {
@@ -73,6 +73,6 @@ export function scheduleWindowsTerminalExit(options = {}) {
 
   const schedule = options.schedule ?? ((callback) => setTimeout(callback, 0));
   const exitProcess = options.exitProcess ?? ((code) => process.exit(code));
-  schedule(() => exitProcess(0));
+  schedule(() => exitProcess(options.exitCode ?? 0));
   return true;
 }

package/src/lib/trellis-runner.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
@@ -72,6 +73,9 @@ const UPSTREAM_UPGRADE_NOTICE = /Your CLI \(([^)]+)\) is behind npm\b/;
  */
 const UPSTREAM_UPGRADE_ACTION = /^Run:\s*trellis upgrade$/;
 
+/** 受管更新由宿主说明版本查询策略，避免依赖上游终端输出格式。 */
+const MANAGED_UPDATE_NOTICE = "  · Trellis 版本由 Flower 固定，已跳过独立版本查询";
+
 /**
  * 正文开始后继续按行过滤的行数上限。
  *
@@ -89,16 +93,33 @@ const UPSTREAM_NOTICE_LINE_BUDGET = 40;
  * 让用户仍然知道版本检查发生过、以及为什么不需要照做。
  *
  * @param {string} line 未去色的原始输出行
+ * @param {{managedUpdate?:boolean}} [options] 是否使用 Flower 管理的更新入口
  * @returns {string|null|undefined} 替换文案;null 表示丢弃该行;undefined 表示不匹配
  */
-export function rewriteUpstreamUpgradeNotice(line) {
+export function rewriteUpstreamUpgradeNotice(line, options = {}) {
   const t = stripAnsi(line).trim();
+  if (options.managedUpdate && /^Latest on npm:\s+\(unable to fetch\)$/.test(t)) {
+    return MANAGED_UPDATE_NOTICE;
+  }
   const notice = UPSTREAM_UPGRADE_NOTICE.exec(t);
   if (notice) return `  · Trellis 版本由 Flower 固定(${notice[1]}),已忽略上游 npm 升级提示`;
   if (UPSTREAM_UPGRADE_ACTION.test(t)) return null;
   return undefined;
 }
 
+/**
+ * 构造捆绑 Trellis 启动参数，仅显式管理的 update 经过隔离引导。
+ * @param {string[]} args 原始上游参数
+ * @param {{managedUpdate?:boolean}} [options] 内部启动选项
+ * @returns {string[]} 传给 Node 的文件与参数
+ */
+export function trellisLaunchArgs(args, options = {}) {
+  const bin = resolveTrellisBin();
+  return options.managedUpdate && args[0] === "update"
+    ? [fileURLToPath(new URL("./trellis-update-entry.js", import.meta.url)), bin, ...args]
+    : [bin, ...args];
+}
+
 /**
  * 用当前 node 执行 trellis bin(普通 spawn),透传子命令与参数。
  *
@@ -106,14 +127,14 @@ export function rewriteUpstreamUpgradeNotice(line) {
  *
  * @param {string[]} args
  * @param {string} cwd
- * @param {object} [opts] { stripBanner }
+ * @param {object} [opts] { stripBanner, managedUpdate }
  * @returns {Promise<number>} 退出码(信号终止返回 128)
  */
 export function runTrellis(args, cwd, opts = {}) {
-  const bin = resolveTrellisBin();
+  const launchArgs = trellisLaunchArgs(args, opts);
   const strip = opts.stripBanner;
   return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [bin, ...args], {
+    const child = spawn(process.execPath, launchArgs, {
       cwd,
       stdio: strip ? ["inherit", "pipe", "inherit"] : "inherit",
       env: strip ? { ...process.env, FORCE_COLOR: "1" } : process.env,
@@ -122,7 +143,7 @@ export function runTrellis(args, cwd, opts = {}) {
       const banner = trellisBannerLines();
       const rl = createInterface({ input: child.stdout });
       rl.on("line", (line) => {
-        const notice = rewriteUpstreamUpgradeNotice(line);
+        const notice = rewriteUpstreamUpgradeNotice(line, { managedUpdate: opts.managedUpdate && args[0] === "update" });
         if (notice !== undefined) {
           if (notice !== null) process.stdout.write(notice + "\n");
           return;
@@ -156,11 +177,12 @@ export function runTrellis(args, cwd, opts = {}) {
  *
  * @param {string[]} args
  * @param {string} cwd
- * @param {object} [opts] { stripBanner, ptySpawn, stdin, stdout, platform }
+ * @param {object} [opts] { stripBanner, managedUpdate, ptySpawn, stdin, stdout, platform }
  * @returns {Promise<number>} 退出码(信号终止返回 128)
  */
 export function runTrellisPty(args, cwd, opts = {}) {
-  const bin = resolveTrellisBin();
+  const launchArgs = trellisLaunchArgs(args, opts);
+  const managedUpdate = opts.managedUpdate && args[0] === "update";
   const stdin = opts.stdin || process.stdin;
   const stdout = opts.stdout || process.stdout;
   const platform = opts.platform ?? process.platform;
@@ -168,7 +190,7 @@ export function runTrellisPty(args, cwd, opts = {}) {
   return new Promise((resolve, reject) => {
     let child;
     try {
-      child = ptySpawn(process.execPath, [bin, ...args], {
+      child = ptySpawn(process.execPath, launchArgs, {
         name: "xterm-256color",
         cols: stdout.columns || 80,
         rows: stdout.rows || 30,
@@ -181,6 +203,8 @@ export function runTrellisPty(args, cwd, opts = {}) {
       return;
     }
 
+    // ConPTY 可能从首帧就进入原样透传；在转发前说明策略，不改写交互控制序列。
+    if (managedUpdate) stdout.write(MANAGED_UPDATE_NOTICE + "\r\n");
     const bannerSet = trellisBannerLines();
     let phase = opts.stripBanner ? "header" : "raw";
     let noticeBudget = UPSTREAM_NOTICE_LINE_BUDGET;
@@ -211,9 +235,9 @@ export function runTrellisPty(args, cwd, opts = {}) {
           stdout.write(line + "\r\n");
           continue;
         }
-        const notice = rewriteUpstreamUpgradeNotice(line);
+        const notice = rewriteUpstreamUpgradeNotice(line, { managedUpdate });
         if (notice !== undefined) {
-          if (notice !== null) stdout.write(notice + "\r\n");
+          if (notice !== null && !(managedUpdate && notice === MANAGED_UPDATE_NOTICE)) stdout.write(notice + "\r\n");
           continue;
         }
         if (phase === "header") {

package/src/lib/trellis-update-entry.js

@@ -0,0 +1,10 @@
+/** Flower 管理的 update 子进程入口；只影响本进程，不改安装目录或全局环境。 */
+import { pathToFileURL } from "node:url";
+import { withoutTrellisUpdateNotice } from "./trellis-update-fetch.js";
+
+const [bin, ...args] = process.argv.slice(2);
+if (!bin || args[0] !== "update") throw new Error("Flower 上游更新入口只接受 update");
+// Commander 需要原始 CLI argv，不能使用 eval 入口或让额外的引导文件成为子命令。
+process.argv = [process.execPath, bin, ...args];
+globalThis.fetch = withoutTrellisUpdateNotice(globalThis.fetch);
+await import(pathToFileURL(bin).href);

package/src/lib/trellis-update-fetch.js

@@ -0,0 +1,18 @@
+/**
+ * 为 Flower 管理的更新隔离上游独立版本提示，保留所有实际资源请求。
+ *
+ * 上游 0.6.14 的 getLatestNpmVersion 只把该响应用于提示，且已有失败降级。
+ * 返回失败而非虚构版本，避免让远程事实与捆绑版本混淆。
+ * @param {Function} originalFetch 原 fetch
+ * @returns {Function} 只跳过精确 GET 提示请求的 fetch
+ */
+export function withoutTrellisUpdateNotice(originalFetch) {
+  return function fetchWithoutNotice(input, options) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input?.url;
+    const method = String(options?.method || input?.method || "GET").toUpperCase();
+    if (method === "GET" && url === "https://registry.npmjs.org/@mindfoldhq/trellis/latest") {
+      return Promise.reject(new Error("Trellis 版本由 Flower 管理，跳过独立版本查询"));
+    }
+    return originalFetch(input, options);
+  };
+}

package/src/lib/update-check-cache.js

@@ -0,0 +1,47 @@
+/**
+ * 判断远程探测缓存是否仍在配置的 interval 内。
+ * @param {object} updateCheck 归一化缓存
+ * @param {Date} [now] 当前时间
+ * @returns {boolean} 是否可复用远端版本证据
+ */
+export function isRemoteCacheFresh(updateCheck, now = new Date()) {
+  if (updateCheck.lastStatus === "offline" || updateCheck.lastErrorCode) return false;
+  if (!updateCheck.lastRemote) return false;
+  if (!updateCheck.lastCheckedAt) return false;
+  const checkedAt = new Date(updateCheck.lastCheckedAt).getTime();
+  if (!Number.isFinite(checkedAt)) return false;
+  return now.getTime() - checkedAt < updateCheck.intervalHours * 60 * 60 * 1000;
+}
+
+/**
+ * 判断缓存的 release notes 是否匹配本次检查范围。
+ *
+ * @param {object} updateCheck 归一化 updateCheck 配置
+ * @param {{from:string|null,to:string|null,channel:string,reason:string}|null} range 本次期望范围
+ * @returns {object|null} 可复用的缓存摘要
+ */
+export function cachedReleaseNotes(updateCheck, range) {
+  const cached = updateCheck.lastReleaseNotes;
+  if (!cached || !range || cached.unavailable) return null;
+  const cachedRange = cached.range || {};
+  if (
+    cachedRange.from !== range.from ||
+    cachedRange.to !== range.to ||
+    cachedRange.channel !== range.channel
+  ) {
+    return null;
+  }
+  if (!Array.isArray(cached.versions) || !cached.versions.length) return null;
+  // 同一版本范围的内容相同;reason 只是触发路径,不能让项目追平场景丢失摘要。
+  return {
+    ...cached,
+    range: {
+      ...cachedRange,
+      from: range.from,
+      to: range.to,
+      channel: range.channel,
+      reason: range.reason,
+    },
+  };
+}
+

package/src/lib/update-check.js

@@ -1,3 +1,6 @@
+import { beginOperationTiming, timeOperation } from "./operation-timing.js";
+import { performance } from "node:perf_hooks";
+import { isRemoteCacheFresh, cachedReleaseNotes } from "./update-check-cache.js";
 import { spawnSync } from "node:child_process";
 import { confirm } from "@inquirer/prompts";
 import chalk from "chalk";
@@ -84,52 +87,92 @@ function parseReleaseNotesByVersion(json) {
 }
 
 /**
- * 取 npm 上 flower-trellis 的更新 metadata。
- *
- * 一次请求 registry 根文档,同时解析 dist-tags 与各版本的 flowerReleaseNotes。任何失败
- * (离线/超时/非 200/解析异常)一律返回 null,调用方继续主流程。
- *
- * @returns {Promise<{tags:{latest:string|null,beta:string|null},releaseNotesByVersion:Record<string,{version:string,body:string,truncated:boolean,source:string}>}|null>} 更新 metadata
+ * 在同一截止时间内读取 registry JSON，预算覆盖响应头及完整响应体。
+ * @param {string} endpoint registry 相对路径
+ * @param {{deadline?:number,timeoutMs?:number,fetchImpl?:Function,abortController?:AbortController}} [options] 请求预算与测试替身
+ * @returns {Promise<object|null>} JSON 或降级空值
  */
-export async function fetchPackageUpdateMetadata() {
-  const ac = new AbortController();
-  const timer = setTimeout(() => ac.abort(), TIMEOUT_MS);
+async function fetchRegistryJson(endpoint, options = {}) {
+  const remaining = (options.deadline ?? performance.now() + (options.timeoutMs ?? TIMEOUT_MS)) - performance.now();
+  const ac = options.abortController ?? new AbortController();
+  if (remaining <= 0 || ac.signal.aborted) return null;
+  // 共享取消状态持久记录超时，避免计时器与单调时钟边界不同步时再次发请求。
+  const timer = setTimeout(() => ac.abort(), Math.ceil(remaining));
   try {
-    const res = await fetch(`${REGISTRY}/${PKG}`, {
+    const res = await (options.fetchImpl || fetch)(`${REGISTRY}/${endpoint}`, {
       signal: ac.signal,
       headers: { Accept: "application/json" },
     });
-    if (!res.ok) return null; // 非 200(404/5xx 等)→ 静默跳过
-    const json = await res.json();
-    const tags = parseDistTags(json);
-    if (!tags) return null;
-    return {
-      tags,
-      releaseNotesByVersion: parseReleaseNotesByVersion(json),
-    };
+    if (!res.ok) {
+      await res.body?.cancel();
+      return null;
+    }
+    return await res.json();
   } catch {
-    return null; // AbortError(超时)/ fetch failed(离线)/ JSON 解析失败 → 静默
+    return null;
   } finally {
     clearTimeout(timer);
   }
 }
 
 /**
- * 取 npm 上 flower-trellis 的 dist-tags;任何失败(离线/超时/非 200/解析异常)一律
- * 返回 null —— 调用方据此「拿不到就当没这回事」继续主流程。
- *
- * 用 AbortController 给内置 fetch 加超时,finally 清除定时器防句柄泄漏。
- * @returns {Promise<{latest:string|null,beta:string|null}|null>} 可用 dist-tags,或失败时 null
+ * 读取完整版本 metadata；仅在需要发布说明时调用。
+ * @param {{deadline?:number,timeoutMs?:number,fetchImpl?:Function,abortController?:AbortController}} [options] 共享网络预算
+ * @returns {Promise<{tags:object,releaseNotesByVersion:object}|null>} 版本与发布说明
+ */
+export async function fetchPackageUpdateMetadata(options = {}) {
+  const json = await fetchRegistryJson(PKG, options);
+  const tags = parseDistTags(json);
+  return tags ? { tags, releaseNotesByVersion: parseReleaseNotesByVersion(json) } : null;
+}
+
+/**
+ * 仅查询 npm dist-tags，避免无更新时下载全部历史版本。
+ * @param {{deadline?:number,timeoutMs?:number,fetchImpl?:Function,abortController?:AbortController}} [options] 共享网络预算
+ * @returns {Promise<{latest:string|null,beta:string|null}|null>} 版本标签或降级空值
  */
-export async function fetchPackageDistTags() {
-  const metadata = await fetchPackageUpdateMetadata();
-  return metadata?.tags ?? null;
+export async function fetchPackageDistTags(options = {}) {
+  const json = await fetchRegistryJson(`-/package/${PKG}/dist-tags`, options);
+  return parseDistTags({ "dist-tags": json });
+}
+
+/**
+ * 为一次检查创建按需读取器；标签与摘要共享预算，完整 metadata 至多读取一次。
+ * @param {{fetchMetadata?:Function,fetchTags?:Function,timeoutMs?:number,fetchImpl?:Function}} [options] 请求替身与预算
+ * @returns {{readTags:Function,readMetadata:Function}} 延迟执行的读取接口
+ */
+export function createUpdateMetadataReader(options = {}) {
+  let deadline;
+  let metadata;
+  const abortController = new AbortController();
+  const requestOptions = () => {
+    deadline ??= performance.now() + (options.timeoutMs ?? TIMEOUT_MS);
+    return { deadline, fetchImpl: options.fetchImpl, abortController };
+  };
+  const readMetadata = () => {
+    metadata ??= timeOperation("版本检查", "读取发布说明", () => Promise.resolve().then(() => (
+      (options.fetchMetadata || fetchPackageUpdateMetadata)(requestOptions())
+    )).catch(() => null));
+    return metadata;
+  };
+  return {
+    readMetadata,
+    async readTags() {
+      // 保留已有完整 metadata 注入点；生产默认始终使用独立的轻量 endpoint。
+      if (options.fetchMetadata && !options.fetchTags) return (await readMetadata())?.tags ?? null;
+      try {
+        return await timeOperation("版本检查", "读取版本标签", () => (options.fetchTags || fetchPackageDistTags)(requestOptions()));
+      } catch {
+        return null;
+      }
+    },
+  };
 }
 
 /**
  * 取 npm 上 flower-trellis 的 latest 版本号。
  *
- * 保留这个导出是为了兼容已有调用方;新逻辑应优先使用 `fetchPackageUpdateMetadata()`。
+ * 保留这个导出是为了兼容已有调用方；新逻辑使用按需读取器共享标签与摘要的网络预算。
  * @returns {Promise<string|null>} latest 版本号,或失败时 null
  */
 export async function fetchLatestVersion() {
@@ -422,7 +465,6 @@ function rememberRemoteTags(target, tags, status, releaseNotes = null) {
       lastRemote: tags,
       lastStatus: status,
       lastErrorCode: null,
-      lastReleaseNotes: null,
     };
     if (releaseNotes && !releaseNotes.unavailable) {
       patch.lastReleaseNotes = releaseNotes;
@@ -450,10 +492,30 @@ function rememberRemoteTags(target, tags, status, releaseNotes = null) {
  *
  * @param {object} ctx cli-args.js parseCliArgs() 产出的上下文(用到 updateCheck / passthrough)
  * @param {string} commandLabel 当前命令名,用于「请重新运行 ft <command>」文案(如 "init"/"update")
- * @param {{fetchMetadata?:typeof fetchPackageUpdateMetadata,report?:typeof reportTelemetry}} [options] 测试替换项
+ * @param {{fetchMetadata?:Function,fetchTags?:Function,fetchImpl?:Function,timeoutMs?:number,report?:Function,confirm?:Function,install?:Function}} [options] 测试替换项
  * @returns {Promise<void>} 注意:用户确认升级且成功时本函数会直接退出进程,不返回
  */
 export async function checkForUpdate(ctx, commandLabel, options = {}) {
+  const finish = beginOperationTiming(commandLabel, "版本检查（含确认等待）");
+  try {
+    return await executeCheckForUpdate(ctx, commandLabel, options, finish);
+  } catch (error) {
+    finish(false);
+    throw error;
+  } finally {
+    finish();
+  }
+}
+
+/**
+ * 执行版本提示与可选升级；直接退出前必须先冻结诊断阶段。
+ * @param {object} ctx 命令上下文
+ * @param {string} commandLabel 命令名
+ * @param {object} options 测试替身
+ * @param {Function} finish 版本检查阶段的幂等结束函数
+ * @returns {Promise<void>} 未升级退出时返回
+ */
+async function executeCheckForUpdate(ctx, commandLabel, options, finish) {
   // 1. 关闭开关:显式 flag 或环境变量
   if (ctx.updateCheck === false || process.env.FLOWER_NO_UPDATE_CHECK) return;
   const updateCheck = readUpdateCheck(ctx.target);
@@ -461,35 +523,37 @@ export async function checkForUpdate(ctx, commandLabel, options = {}) {
   // 2. npx 本就是最新版,跳过(连通知都不打,避免误导)
   if (isRunningViaNpx(import.meta.url)) return;
 
-  // 3. 尽力而为取 dist-tags;拿不到就静默退出
-  const fetchMetadata = options.fetchMetadata || fetchPackageUpdateMetadata;
+  const reader = createUpdateMetadataReader(options);
+  const fromCache = isRemoteCacheFresh(updateCheck);
   const report = options.report || reportTelemetry;
-  const [metadata] = await Promise.all([
-    fetchMetadata(),
-    Promise.resolve()
-      .then(() => report(ctx.target, "version_check"))
-      .catch(() => null),
+  if (!fromCache) console.log("  · 正在检查 Flower 版本");
+  const [tags] = fromCache ? [updateCheck.lastRemote] : await Promise.all([
+    reader.readTags(),
+    Promise.resolve().then(() => report(ctx.target, "version_check")).catch(() => null),
   ]);
-  if (!metadata) return;
-  const tags = metadata.tags;
+  if (!tags) return;
 
-  // 4. 根据本地版本通道生成推荐;无推荐时不打扰
   const current = flowerVersion();
   const recommendation = getUpdateRecommendation(current, tags);
-  const releaseNotes = recommendation
-    ? buildReleaseNotesSummary(metadata.releaseNotesByVersion, {
-        from: current,
-        to: recommendation.version,
-        channel: recommendation.tag,
-        reason: "update_available",
-      })
-    : null;
-  rememberRemoteTags(
-    ctx.target,
-    tags,
-    recommendation ? "update_available" : "up_to_date",
-    releaseNotes,
-  );
+  const range = recommendation ? {
+    from: current,
+    to: recommendation.version,
+    channel: recommendation.tag,
+    reason: "update_available",
+  } : null;
+  const releaseNotes = cachedReleaseNotes(updateCheck, range) || (range
+    ? buildReleaseNotesSummary((await reader.readMetadata())?.releaseNotesByVersion, range)
+    : null);
+  if (!fromCache) {
+    rememberRemoteTags(ctx.target, tags, recommendation ? "update_available" : "up_to_date", releaseNotes);
+  } else if (releaseNotes && !releaseNotes.unavailable) {
+    // 摘要补拉不能把旧标签伪装成刚确认的远端版本。
+    try {
+      if (readManifest(ctx.target) || new ProjectStore(ctx.target).readLock()) {
+        writeUpdateCheck(ctx.target, { lastReleaseNotes: releaseNotes });
+      }
+    } catch { /* 缓存失败不阻断更新。 */ }
+  }
   if (!recommendation) return;
 
   // 5. 打印发现新版本通知(粉色品牌色,与 banner 一致)
@@ -511,7 +575,7 @@ export async function checkForUpdate(ctx, commandLabel, options = {}) {
   }
 
   // 7. 交互:询问是否升级(@inquirer/confirm,返回 boolean)
-  const doUpgrade = await confirm({
+  const doUpgrade = await (options.confirm || confirm)({
     message: `是否现在升级到 ${recommendation.version}(${recommendation.tag})?(升级后需重新运行命令)`,
     default: true,
   });
@@ -521,11 +585,16 @@ export async function checkForUpdate(ctx, commandLabel, options = {}) {
   }
 
   // 8. 执行全局升级。失败(含 EACCES 权限问题、npm 不存在)不自行提权,降级为打印手动命令
-  const res = installFlowerVersion(recommendation.version);
+  const res = timeOperation(commandLabel, "全局安装（含依赖与postinstall）", () => (
+    (options.install || installFlowerVersion)(recommendation.version)
+  ));
   if (res.status === 0) {
     console.log(`\n  ✓ 已升级到 ${recommendation.version}(${recommendation.tag})`);
     console.log(`  · 请重新运行 ft ${commandLabel} 以使用新版本`);
     console.log("  · 强化包随版本更新,升级后可 ft update 重新叠加到现有项目");
+    // process.exit 不会展开调用者的 finally；成功升级的旧进程退出前先结束阶段与父总计。
+    finish();
+    ctx.finishUpdateTiming?.();
     // 当前进程内存里仍是旧代码,必须退出由用户重跑新版本(不做 re-exec,规避权限/平台/进程态坑)
     process.exit(0);
   } else {