dsh-mobile-plugin 0.1.97 → 0.1.98

package/lib/index.js

@@ -26,7 +26,7 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { createRuntime } from './shell/runtime.js'
 import * as updater from './shell/updater.js'
-import { installedPackageDir, installedVersion, profileNodeModules } from './shell/manager.js'
+import { installedPackageDir, installedVersion, profileNodeModules, snapshotRunningGeneration } from './shell/manager.js'
 import { createDeviceOta } from './shell/device-ota.js'
 
 export const name = 'dsh-mobile-plugin'
@@ -81,33 +81,25 @@ export function apply(ctx) {
   }
 
   /**
-   * 装新版（实现自己装，见 `shell/updater.js`），装完**就地换代**。
-   *
-   * 手动与自动走的是同一条路：手动只是「现在就做一次」。装的那一步报的 `restartRequired` 一律
-   * 不照做 —— 外壳自己换代码，这正是这个文件存在的全部理由。
+   * 装之前把正在跑的那一代备份进回退目录：包管理器一跑就没得备份了。失败不挡更新，只记一句。
    */
-  async function applyUpdate({ force = false } = {}) {
-    const outcome = await updater.installIfNeeded(base(), {
-      force,
-      // 宿主发布的包管理器优先（PATH 上那个的版本可能和 profile 的 store 对不上，实测
-      // 10.x 装 11.x 的 profile 直接 `ERR_PNPM_UNEXPECTED_STORE`）；agents 是「有对话在跑
-      // 就别换文件」那道闸的判据。自动更新永远不带 force。
-      packageManager: () => hostService('profileContext')?.packageManager ?? null,
-      agents: () => hostService('agents'),
+  const snapshotRunning = () => {
+    const status = runtime.status()
+    const result = snapshotRunningGeneration(status)
+    if (result?.created) log('info', 'dsh-mobile-plugin: 更新前已把 %s 复制进回退目录', status.version)
+    else if (result?.error) log('warn', 'dsh-mobile-plugin: 回退副本没做成：%s', result.error)
+    return result
+  }
+
+  /**
+   * 装新版（实现自己装，见 `shell/updater.js`），装完**就地换代**。编排、落账与「换不过来
+   * 就重试」都在 `updater.performUpdate` 里 —— 入口只留装载逻辑，行数钉着。
+   */
+  async function applyUpdate({ force = false, auto = false } = {}) {
+    return updater.performUpdate({
+      runtime, base, hostService, updateState, force, auto, log,
+      beforeInstall: snapshotRunning,
     })
-    let swapped = false
-    let status = runtime.status()
-    if (outcome.installed) {
-      status = await runtime.reload()
-      swapped = true
-      log('info', 'dsh-mobile-plugin: 已就地换到 %s（无需重启 DSH）', status.version)
-    } else if (outcome.state && outcome.state !== 'succeeded') {
-      log('warn', 'dsh-mobile-plugin: 更新没有成功（%s）%s', outcome.state, outcome.failure?.message || '')
-    }
-    updateState.lastApply = { ...outcome, swapped }
-    updateState.appliedAt = new Date().toISOString()
-    if (outcome.installed) updateState.lastError = null
-    return { ...outcome, swapped, status }
   }
 
   // 换代前要知道有没有请求在飞（见 runtime.drain）。宿主 webServer 没有中间件机制，所以
@@ -165,10 +157,12 @@ export function apply(ctx) {
     .start(ctx)
     .then(() => {
       log('info', 'dsh-mobile-plugin: 已装载 %s（来源 %s）', runtime.status().version, runtime.status().source)
-      // 每 10 分钟让已落盘的正式版接管 OTA；自动安装仍由开关控制。
+      // 每 10 分钟让已落盘的正式版接管 OTA，并补上「盘上比运行中新」的那一次换代；
+      // 自动安装仍由开关控制。补换代不受开关管：它不下载任何东西，只是让已经在盘上的代码生效。
       const timer = setInterval(() => {
         deviceOta.reconcileOfficial()
-          .then(() => updater.autoUpdateEnabled() ? applyUpdate() : null)
+          .then(() => updater.reconcileInstalledGeneration({ runtime, log }))
+          .then(() => updater.autoUpdateEnabled() ? applyUpdate({ auto: true }) : null)
           .catch(error => {
             updateState.lastError = String(error?.message || error)
             log('warn', 'dsh-mobile-plugin: 更新检查失败：%s', updateState.lastError)
@@ -179,7 +173,7 @@ export function apply(ctx) {
       // 启动后延后一次：别和绑端口、连隧道抢带宽。
       if (updater.autoUpdateEnabled()) {
         const kick = setTimeout(() => {
-          applyUpdate().catch(error => {
+          applyUpdate({ auto: true }).catch(error => {
             updateState.lastError = String(error?.message || error)
             log('warn', 'dsh-mobile-plugin: 启动时的自动更新失败：%s', updateState.lastError)
           })

package/lib/shell/device-ota.js

@@ -72,20 +72,70 @@ function clearSuperseded(version) {
   if (!validVersion(version)) return
   for (const release of availableOta()) if (compareVersion(version, release.version) >= 0) fs.rmSync(path.dirname(release.pkgDir), { recursive: true, force: true })
 }
+/**
+ * 把**正在跑的那一代**复制成一份能从盘上回退的包（`<root>/<version>/dsh-mobile-plugin`）。
+ *
+ * 为什么必须复制：包管理器装新版会把旧的 store 目录整个带走，旧代码从此只剩内存里那一份。
+ * 新版装上了却起不来时，外壳当场回滚到内存里那份（看着一切正常）；可**下次重启**就只能拿
+ * 盘上那份坏的去装载，所有代都失败 = 插件整个不在（手机连不上、面板也没有）。回退目录本来
+ * 就是干这个的（`availableOta` 列出来，启动时按版本从高到低逐个试），缺的只是「有人往里放
+ * 一份能跑的」。
+ *
+ * 调用点是「真正要装之前」（见 `updater.js` 的 `beforeInstall`），所以拿到的就是那份还在跑、
+ * 还装得上的代码。`node_modules` 不复制：那是 profile 的依赖树，复制既慢又会被相对布局骗到；
+ * 落在 profile 里的这一代与 OTA 代走同一条解析链（见 `manager.js` 的 `moveOtaRootIntoProfile`）。
+ *
+ * 不抛错：备份是「多一层保险」，它失败不该挡住一次更新 —— 原因如实回给调用方去记日志。
+ */
+export function snapshotGeneration(sourceDir, version) {
+  if (!validVersion(version) || typeof sourceDir !== 'string' || !sourceDir) {
+    return { created: false, error: '版本号或目录不可用' }
+  }
+  const target = path.join(ROOT(), version, PACKAGE)
+  if (fs.existsSync(path.join(target, 'lib', 'impl.js'))) return { created: false, existing: true, dir: target }
+  let source = sourceDir
+  try {
+    source = fs.realpathSync(sourceDir)
+  } catch {
+    return { created: false, error: '要备份的那一代已经读不到了' }
+  }
+  if (!fs.existsSync(path.join(source, 'lib', 'impl.js'))) return { created: false, error: '要备份的那一代缺 lib/impl.js' }
+  fs.mkdirSync(ROOT(), { recursive: true })
+  // 先落到 `.staging-*`（`availableOta` 与 `sweepStaging` 都按这个前缀跳过/回收），
+  // 复制完整了再一次性改名为 `<version>`：半个包不能被当成一代。
+  const staging = fs.mkdtempSync(path.join(ROOT(), '.staging-fallback-'))
+  try {
+    fs.cpSync(source, path.join(staging, PACKAGE), {
+      recursive: true,
+      // 软链接按实体复制：旧布局里凭据包有时是「与插件包同级」的链接，照着链子复制会在旧目录
+      // 被删之后悬空 —— 这一份必须自己就装得起来，所以把链接指向的内容抄实。
+      dereference: true,
+      filter: entry => path.basename(entry) !== 'node_modules',
+    })
+    fs.rmSync(path.join(ROOT(), version), { recursive: true, force: true })
+    movePath(staging, path.join(ROOT(), version))
+    return { created: true, dir: target }
+  } catch (error) {
+    fs.rmSync(staging, { recursive: true, force: true })
+    return { created: false, error: String((error && error.message) || error) }
+  }
+}
 export function createDeviceOta({ fetchImpl = fetch, installed = () => null, platform = PLATFORM, channel = CHANNEL, runtime = null } = {}) {
   async function reconcileOfficial() {
     const active = runtime?.status()
     const officialVersion = installed()
     if (!runtime || !validVersion(officialVersion)) return { switched: false, status: active ?? null }
     if (active?.source === 'installed') {
-      clearSuperseded(officialVersion)
+      // 只有「跑着的就是他盘上那一版」才算接管成功，这时才回收回退包。
+      // 换代失败时跑着的仍是旧版、盘上已是新版 —— 那份副本是下次重启唯一的活路，不能删。
+      if (active.version === officialVersion) clearSuperseded(officialVersion)
       return { switched: false, status: active }
     }
     if (active?.source !== 'ota' || !validVersion(active.version) || compareVersion(officialVersion, active.version) < 0) {
       return { switched: false, status: active ?? null }
     }
     const status = await runtime.reload()
-    if (status?.source === 'installed') clearSuperseded(officialVersion)
+    if (status?.source === 'installed' && status.version === officialVersion) clearSuperseded(officialVersion)
     return { switched: status?.source === 'installed', status }
   }
   /** 问一次中转「我该装哪个版本」；没有就返回 null（不抛）。 */

package/lib/shell/manager.js

@@ -32,7 +32,7 @@ import fs from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import { availableOta, configureOtaRoot } from './device-ota.js'
+import { availableOta, configureOtaRoot, snapshotGeneration } from './device-ota.js'
 import { movePath } from './ota-package.js'
 import { dshHome } from '../shared/paths.js'
 
@@ -161,6 +161,20 @@ export function installedVersion() {
   return dir ? readPackageVersion(path.join(dir, 'package.json')) : null
 }
 
+/**
+ * 装之前把**正在跑的那一代**备份进回退目录（换代的保险，见 `device-ota.js` 的
+ * `snapshotGeneration`：包管理器一跑就把旧目录带走了）。
+ *
+ * 只有「跑着的就是盘上装着的那一代」才备份 —— 跑 OTA 代时盘上那份不是活代码，复制它对不上号。
+ * 返回 `snapshotGeneration` 的结果，拿不到就回 null（备份失败不该挡住更新）。
+ */
+export function snapshotRunningGeneration(running) {
+  const dir = installedPackageDir()
+  if (!dir || !running || !running.version || running.source !== 'installed') return null
+  if (installedVersion() !== running.version) return null
+  return snapshotGeneration(dir, running.version)
+}
+
 /**
  * 取版本号最高的代。
  *

package/lib/shell/updater.js

@@ -31,7 +31,7 @@ import path from 'node:path'
 import { createHash } from 'node:crypto'
 import { createRequire } from 'node:module'
 import { pathToFileURL } from 'node:url'
-import { installedPackageDir, installedVersion, profileNodeModules } from './manager.js'
+import { installedPackageDir, installedVersion, profileNodeModules, compareVersion } from './manager.js'
 
 const require_ = createRequire(import.meta.url)
 const { dshHome } = require_('../shared/paths.js')
@@ -82,7 +82,7 @@ function installedPackageDirSafe() {
  */
 export function shellFingerprint(pkgDir) {
   if (!pkgDir) return null
-  const files = ['lib/index.js', 'lib/shell/runtime.js', 'lib/shell/manager.js', 'lib/shell/updater.js']
+  const files = ['lib/index.js', 'lib/shell/runtime.js', 'lib/shell/manager.js', 'lib/shell/updater.js', 'lib/shell/device-ota.js', 'lib/shell/ota-package.js']
   const hash = createHash('sha256')
   let seen = 0
   for (const rel of files) {
@@ -227,7 +227,7 @@ const TERMINAL = new Set(['succeeded', 'failed', 'cancelled', 'rolled-back'])
  * 装完了但盘上版本没变（市场报成功、文件没落），这里如实返回 `installed: false`，不让调用方
  * 以为换过代码 —— 「状态说成功、代码没换」是这个仓库吃过最贵的一次亏。
  */
-export async function installIfNeeded(base, { name = PACKAGE_NAME, force = false, onEvent = () => {}, packageManager = () => null, agents = () => null, now = Date.now } = {}) {
+export async function installIfNeeded(base, { name = PACKAGE_NAME, force = false, onEvent = () => {}, packageManager = () => null, agents = () => null, beforeInstall = null, now = Date.now } = {}) {
   const before = installedVersion()
   // 装归实现自己（2026-10-11 起）：盘上那一代里有 `update-install.cjs` 就走它。判定（有没有
   // 新版、`link:` 来源不碰、有 agent 在跑就先别换文件）也一并交给它，别在这里抄第二份 ——
@@ -242,6 +242,8 @@ export async function installIfNeeded(base, { name = PACKAGE_NAME, force = false
       // 实现在代里，它没有宿主 ctx，只有外壳有。
       packageManager: packageManager(),
       agents: agents(),
+      // 装之前把正在跑的那一代备份走：包管理器一跑，旧目录就没了。
+      beforeInstall,
     })
     return {
       installed: outcome.installed === true,
@@ -307,6 +309,151 @@ export async function installIfNeeded(base, { name = PACKAGE_NAME, force = false
   }
 }
 
+/**
+ * 换代尝试的记账：同一个版本自动只试一次。
+ *
+ * 一个起不来的新版每 10 分钟把手机抖一下没有任何意义 —— 第一次失败之后就该停下，等人按
+ * 那颗按钮（手动不受这个限制：那是「我知道，再来一次」）。进程重启后这份记录清零，
+ * 而重启本来就会走一遍正常装载，不需要它。
+ */
+const swapAttempts = new Map()
+
+/** 同一时刻只跑一次更新：自动轮询与手按按钮撞一起时，第二个直接等第一次的结果。 */
+let applying = null
+
+/**
+ * 一次完整的更新：装（若需要）→ 换代 → 落账。
+ *
+ * 手动与自动走的是同一个函数 —— 自动只是「没人按」的那一种（`auto: true`）。
+ * 账必须**成功失败都落**：这套东西最贵的一次教训是「状态说成功、代码没换」，第二贵的是
+ * 「失败了但没人记得」，面板与手机都靠这本账判结果，漏落一次它们就永远停在上一次。
+ */
+export function performUpdate(options = {}) {
+  if (applying) return applying
+  applying = runUpdate(options).finally(() => { applying = null })
+  return applying
+}
+
+async function runUpdate({ runtime, base, hostService = () => null, updateState, beforeInstall = null, log = () => {}, force = false, auto = false } = {}) {
+  const status = () => {
+    try { return runtime.status() ?? {} } catch { return {} }
+  }
+  const beforeVersion = installedVersion() ?? status().version ?? null
+  const runningBefore = status().version ?? null
+  let outcome
+  try {
+    outcome = await installIfNeeded(base, {
+      force,
+      beforeInstall,
+      packageManager: () => hostService('profileContext')?.packageManager ?? null,
+      agents: () => hostService('agents'),
+    })
+  } catch (error) {
+    // 装那步就炸了（注册表 / 网络 / 权限）：账照样要落，否则面板停在上一轮、手机那边
+    // 只能等到超时才说得出「没成」。
+    const message = String(error?.message || error)
+    updateState.lastApply = {
+      installed: false,
+      skipped: false,
+      state: 'failed',
+      beforeVersion,
+      installedVersion: beforeVersion,
+      swapped: false,
+      restartRequired: false,
+      refreshRequired: false,
+      retryable: false,
+      failure: { code: 'install_failed', message },
+    }
+    updateState.appliedAt = new Date().toISOString()
+    updateState.lastError = message
+    throw error
+  }
+
+  const disk = installedVersion()
+  // 要换代时换到**盘上那一份**：装成功了是它；「早就装上了、只是没换过来」也是它。
+  const newerOnDisk = disk !== null && runningBefore !== null && compareVersion(disk, runningBefore) > 0
+  let swapped = false
+  let swapFailure = null
+  let deferred = false
+  if (outcome.installed === true || newerOnDisk) {
+    const attempt = await swapTo(runtime, disk ?? runningBefore, { auto, log })
+    swapped = attempt.swapped
+    swapFailure = attempt.failure
+    deferred = attempt.deferred === true
+  }
+  const lastApply = {
+    ...outcome,
+    installed: outcome.installed === true,
+    swapped,
+    state: swapFailure ? 'installed-not-swapped' : (outcome.state ?? (outcome.installed || outcome.skipped ? 'succeeded' : 'failed')),
+    failure: swapFailure ?? outcome.failure ?? null,
+    // 换代由外壳就地做，市场那套「装完要重启」在本项目一律不照做。只为如实上报。
+    restartRequired: false,
+    refreshRequired: false,
+  }
+  updateState.lastApply = lastApply
+  updateState.appliedAt = new Date().toISOString()
+  if (lastApply.installed && !swapFailure) updateState.lastError = null
+  if (swapFailure && !deferred) {
+    // 装上了、换不过来：抛给路由（桌面按 500 + `swap_failed` 说人话），账已经落了，
+    // 手机读 status 也能立刻判出结果，不必等到超时。
+    throw new Error(swapFailure.message)
+  }
+  return { ...lastApply, status: status() }
+}
+
+/**
+ * 换到盘上那一代。
+ *
+ * 失败只回错误、不抛：调用方要先落账再决定要不要抛。`auto` 为真时同一版本只试一次
+ * （见 `swapAttempts`），手动调用不受限制。
+ */
+async function swapTo(runtime, target, { auto = false, log = () => {} } = {}) {
+  const key = String(target ?? '')
+  const tried = swapAttempts.get(key) ?? 0
+  if (auto && tried >= 1) {
+    return {
+      swapped: false,
+      deferred: true,
+      failure: {
+        code: 'swap_deferred',
+        message: `盘上的 ${key} 已经自动试过一次换代、没成：重启一次 DSH 才会用它，或者再按一次更新重试。`,
+      },
+    }
+  }
+  swapAttempts.set(key, Math.max(tried, 1))
+  try {
+    const status = await runtime.reload()
+    swapAttempts.delete(key)
+    log('info', 'dsh-mobile-plugin: 已就地换到 %s（无需重启 DSH）', status?.version ?? key)
+    return { swapped: true, status }
+  } catch (error) {
+    return {
+      swapped: false,
+      failure: { code: 'swap_failed', message: `新版已经装到盘上（${key}），但换代码没成：${String(error?.message || error)}` },
+    }
+  }
+}
+
+/**
+ * 盘上比运行中新：补一次换代。
+ *
+ * 什么时候会走到这里：上一次换代失败了（回滚到旧代继续跑，盘上已是新版），或者新版是别的
+ * 途径装进来的（市场界面、手工装）。这两种情况下盘上的代码不会自己生效 —— 而这个插件存在
+ * 的理由就是「不用重启 DSH」，所以它得自己补上这一步。
+ */
+export async function reconcileInstalledGeneration({ runtime, log = () => {} } = {}) {
+  let running = null
+  try { running = runtime.status()?.version ?? null } catch { return null }
+  const disk = installedVersion()
+  if (!disk || !running || compareVersion(disk, running) <= 0) return null
+  // 不在这里喊话：真去换时 `swapTo` 会记成功、失败那条下面自己记。卡住的机器每 10 分钟
+  // 一行「补一次换代」纯属噪声，而真相在 `lastApply`（面板「运行中 / 盘上」两列也在报）。
+  const attempt = await swapTo(runtime, disk, { auto: true, log })
+  if (attempt.failure && !attempt.deferred) log('warn', 'dsh-mobile-plugin: %s', attempt.failure.message)
+  return attempt.status ?? null
+}
+
 /** 自动更新开关的落盘文件：`<DSH_HOME>/storages/mobile-plugin/auto-update.json`。 */
 function autoUpdateFile() {
   return path.join(dshHome(), 'storages', 'mobile-plugin', 'auto-update.json')

package/lib/update-install.cjs

@@ -281,6 +281,8 @@ function run(command, args, { cwd, env, timeoutMs, spawnImpl = spawn }) {
  * @param {string} options.profileNodeModules profile 的 `node_modules` 目录
  * @param {string} options.version           要装的版本（注册表给的）
  * @param {boolean} [options.force]          true = 跳过「新发布先晾一会儿」的门槛
+ * @param {() => any} [options.beforeInstall] 真正跑包管理器**之前**调一次（外壳用它把正在跑的
+ *   那一代复制进回退目录）。包管理器一跑就把旧的 store 目录清掉了，晚一步没得复制。
  * @returns {Promise<{installed, skipped, beforeVersion, installedVersion, source, command, output, failure}>}
  */
 async function installLatest({
@@ -296,6 +298,7 @@ async function installLatest({
   // 宿主发布的调用方式（`profileContext.packageManager`）。**优先用它**，理由见
   // `normalizeInvocation` 的文件注释（版本对不上会把 profile 的 store 认错）。
   packageManager = null,
+  beforeInstall = null,
   onEvent = () => {},
 } = {}) {
   const beforeVersion = installedVersion(profileNodeModules, name);
@@ -356,6 +359,14 @@ async function installLatest({
     );
   }
 
+  // 备份正在跑的那一代：包的活就落在下面那一行 spawn 上，它一跑旧目录就没了。
+  // 备份失败不该挡住更新（那是多一层保险），所以这里吞掉它的异常，由调用方记日志。
+  if (typeof beforeInstall === 'function') {
+    try {
+      await beforeInstall({ beforeVersion, command: null });
+    } catch { /* 备份失败不挡更新 */ }
+  }
+
   const spec = `${name}@${version}`;
   const releaseAgeFlag = '--config.minimum-release-age=0';
   const args = picked.manager === 'pnpm'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.1.97",
+  "version": "0.1.98",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (0.2.0-rc.2 compatible, peers resolved by the host)",
   "license": "MIT",
   "type": "module",