dsh-pwsh-plugin 0.2.14 → 0.2.17

package/plugin/index.mjs

@@ -31,9 +31,6 @@
 
 import { readFileSync } from 'node:fs'
 import { DEFAULT_MAX_OUTPUT_BYTES, bootArgv, startSession } from './session.mjs'
-import { installReleaseLive, startAutoUpdate } from './auto-update.mjs'
-import { preflightInstall } from './update-apply.mjs'
-import { UpdateChecker } from './update-check.mjs'
 
 /** 加载器诊断里显示的插件名。 */
 export const name = 'pwsh-run'
@@ -155,11 +152,6 @@ export function apply(ctx, config) {
   const maxOutputBytes = Number.isSafeInteger(config?.maxOutputBytes) && config.maxOutputBytes > 0 ? config.maxOutputBytes : DEFAULT_MAX_OUTPUT_BYTES
   // 明确放弃边界的唯一开关：策略服务缺席时默认拒绝启动，只有这里能改主意。
   const allowUnconfined = config?.allowUnconfined === true
-  // 更新检查：查到新版本时在当次调用的输出末尾挂一行。
-  const updateCheck = config?.updateCheck !== false
-  // 自动更新：查到新版本就自己装上，装上即生效（HMR 在场时无需重启）。默认开——
-  // 用户装这个插件图的是「命令不再被转义」，不该再手动盯版本。
-  const autoUpdate = config?.autoUpdate !== false
 
   // 沙箱服务每次启动会话时再取：插件 apply 可能早于沙箱服务挂载，
   // 而沙箱缺席时插件仍需能加载（启动会话时给出明确错误即可）。
@@ -173,16 +165,6 @@ export function apply(ctx, config) {
     return sandboxPolicy.resolve(session === undefined ? {} : { session })
   }
 
-  /**
-   * 安装闸门：自动更新与手动安装共用。
-   *
-   * 热替换会执行本插件的 effect 清理函数，那里 dispose 掉全部常驻会话——正在跑的脚本
-   * 会连人带马被掐断，与直接断电无异。所以安装前先确认没有调用在跑；置位与检查必须在
-   * 同一个同步块里完成，否则中间会挤进一条新调用。
-   */
-  let activeRuns = 0
-  let installing = false
-
   /** sessionId -> Promise<PwshSession>。用 Promise 占位，避免并发首调用各起一个进程。 */
   const sessions = new Map()
 
@@ -196,33 +178,6 @@ export function apply(ctx, config) {
     if (session !== undefined && session !== null) await session.dispose()
   }
 
-  /**
-   * 申请安装权：只有「没有调用在跑、也没有别人在装」时才拿得到。
-   *
-   * 检查与置位放在同一个同步块里，中间不会挤进新调用——否则就会出现
-   * 「刚判断空闲、一条调用起来、安装把它的会话掐掉」这种时序空档。
-   */
-  const beginInstall = () => {
-    if (installing || activeRuns > 0) return false
-    installing = true
-    return true
-  }
-  const endInstall = () => { installing = false }
-  /** 交给自动更新循环：忙就别装，推迟整轮。 */
-  const installGate = { tryAcquire: beginInstall, release: endInstall }
-
-  /**
-   * 安装进行中到达的调用先等着：此刻建出来的会话会在热替换那一刻被 dispose，
-   * 等于刚起就断。等到安装收尾再继续——之后的会话属于安装后的世界。
-   */
-  const waitForInstall = async () => {
-    const deadline = Date.now() + 120000
-    while (installing) {
-      if (Date.now() > deadline) throw new Error('pwsh_run: an update is being installed and has not finished; retry in a moment')
-      await new Promise((resolve) => setTimeout(resolve, 100))
-    }
-  }
-
   /** 取一个活着的会话，必要时新建；超出上限淘汰最久未用的。 */
   const acquire = async (key, workdir, agent, signal) => {
     const existing = sessions.get(key)
@@ -316,147 +271,9 @@ export function apply(ctx, config) {
     sessions.clear()
   }, 'pwsh-run.sessions')
 
-  // 更新检查：只读 npm registry 的 dist-tags、只记判决，从不自己安装。
-  // 发现新版本时不改工具描述（描述在注册时就固定了），而是把提示挂在每次调用的
-  // 输出末尾一次——够模型看见，也不至于每次刷。
-  const checker = updateCheck
-    ? new UpdateChecker({
-        log: (line) => {
-          try {
-            ctx.logger?.info?.('pwsh-run: %s', line)
-          } catch {
-            // 日志服务缺席时不影响工具本身。
-          }
-        },
-      })
-    : undefined
-  // 自动更新循环自成一个 effect：它比 checker 多一层「装上即生效」的动作，
-  // 失败要退避、要记装过的版本，这些都在 auto-update.mjs 里。
-  ctx.effect(() => {
-    const stopAuto = autoUpdate && checker !== undefined
-      ? startAutoUpdate(ctx, checker, {
-          log: (line) => { try { ctx.logger?.info?.('pwsh-run: %s', line) } catch { /* 日志缺席不影响更新 */ } },
-          installGate,
-          ...(Number.isSafeInteger(config?.autoUpdateDelayMs) && config.autoUpdateDelayMs >= 0 ? { firstDelayMs: config.autoUpdateDelayMs } : {}),
-        })
-      : undefined
-    return () => stopAuto?.()
-  }, 'pwsh-run.auto-update')
-
-  // 提示用的定时检查只在自动更新关闭时才起：自动更新的循环自己就会调 check()，
-  // 两边都开着等于每 12 小时查两次。
-  ctx.effect(() => {
-    if (checker === undefined || autoUpdate) return undefined
-    checker.start()
-    return () => checker.stop()
-  }, 'pwsh-run.update')
 
-  /**
-   * 更新工具：把「查到」与「装」拆成同一入口的两个动作。
-   *
-   * 为什么要有它
-   *   只把提示挂在 pwsh_run 输出末尾时，模型看见了也无从下手（它拿不到 profile 名，
-   *   也不知道该不该重启）。给出一个能被调用的动作，比给一句话可靠。
-   *
-   * 为什么装这一步不自己下载
-   *   见 update-apply.mjs 的头注释：本插件是 profile 的一个 bundle 依赖，版本钉在
-   *   package.json 与 pnpm-lock.yaml 里，绕开包管理器改文件会让 lockfile 与磁盘不一致。
-   */
-  ctx.effect(() => ctx.tools.register({
-    name: 'pwsh_run_update',
-    description: [
-      'Check for, and optionally install, a newer release of the pwsh_run plugin.',
-      '* action "check" reads the npm registry dist-tags once and reports the verdict; it never installs anything.',
-      '* action "install" hands the pinned version spec (<package>@X.Y.Z) to DSH\'s own plugin manager (the same service the Plugins page uses), which runs pnpm and rolls back on failure.',
-      '* Installing writes the package to the profile. Where the host runs its HMR service, the new code is already live when this returns; otherwise the running process keeps the old modules until DSH restarts. The result says which of the two happened.',
-      '* Only published stable versions are considered; pre-releases are never pushed. The version actually installed is read back from disk, because pnpm\'s minimumReleaseAge policy can install an older release than the one requested.',
-      '* An install replaces this plugin in place, which terminates the persistent pwsh sessions. It is therefore refused while a pwsh_run call is running; retry after that call finishes (the automatic updater applies the same rule on its own).',
-    ].join('\n'),
-    parameters: {
-      type: 'object',
-      properties: {
-        action: {
-          type: 'string',
-          enum: ['check', 'install'],
-          description: 'check (default): report whether a newer release exists. install: also install the newest release.',
-        },
-      },
-      additionalProperties: false,
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: false,
-        properties: { text: { type: 'string' } },
-        required: ['text'],
-      },
-      render: (_args, value) => [{ type: 'text', text: value.text }],
-    },
-    async execute(args) {
-      if (checker === undefined) {
-        return { text: 'pwsh_run update checks are disabled in this profile (config.updateCheck: false), so pwsh_run_update has nothing to do.' }
-      }
-      const action = args?.action === 'install' ? 'install' : 'check'
-      const state = await checker.check()
-      const doc = checker.document()
-      const lines = ['state: ' + String(doc.state)]
-      if (doc.running !== undefined) lines.push('running: ' + doc.running)
-      if (doc.latest !== undefined) lines.push('newest release: ' + doc.latest)
-      if (doc.spec !== undefined) lines.push('install spec: ' + doc.spec)
-      if (doc.error !== undefined) lines.push('error: ' + String(doc.error))
-      if (state.state !== 'available') {
-        // failed 与 current 必须分开说：查不到的时候说「已是最新」是句谎话。
-        if (state.state === 'current') {
-          lines.push(action === 'install'
-            ? 'Nothing to install: this is the newest release the source publishes.'
-            : 'No newer release.')
-        }
-        else {
-          // 这条分支上 doc.spec 是 undefined，插值只会印出一个字面占位符，所以给模板。
-          lines.push('Could not reach the npm registry, so whether a newer version exists is unknown. '
-            + 'Run the check again later, or upgrade by hand: dsh plugin --profile <name> add "<package>@X.Y.Z"')
-        }
-        return { text: lines.join('\n') }
-      }
-      if (action === 'check') {
-        lines.push('Run this again with action "install", or run: dsh plugin --profile <name> add "' + String(doc.spec) + '"')
-        return { text: lines.join('\n') }
-      }
-      // 装之前先问一句值不值得装：磁盘上已经是这个版本、或者这个 tag 的包根本没改过版本号，
-      // 装下去只会被 plugin-manager 判 already-installed。判掉后照实说清是哪一种。
-      const unnecessary = preflightInstall(ctx, checker, String(doc.spec))
-      if (unnecessary !== null) {
-        lines.push('install: ' + unnecessary.outcome)
-        lines.push(unnecessary.text)
-        return { text: lines.join('\n') }
-      }
-      // 安装会热替换本插件，从而 dispose 掉所有常驻会话。正有调用在跑时先不装：
-      // 掐断别人跑到一半的脚本，代价远大于晚几十秒。
-      if (!beginInstall()) {
-        lines.push('install: postponed')
-        lines.push('A pwsh_run call is running right now, and installing would terminate its session mid-script. '
-          + 'Retry once that call has finished; auto-update performs this same check on its own.')
-        return { text: lines.join('\n') }
-      }
-      let outcome
-      try {
-        outcome = await installReleaseLive(ctx, String(doc.spec), { requestId: 'pwsh-run-update' })
-      } finally {
-        endInstall()
-      }
-      lines.push('install: ' + outcome.outcome)
-      lines.push(outcome.text)
-      if (outcome.installedVersion !== undefined && outcome.installedVersion !== doc.latest) {
-        lines.push('Installed version on disk: ' + outcome.installedVersion + ' (requested ' + String(doc.latest) + ').')
-      }
-      if (outcome.ok !== true && doc.spec !== undefined) lines.push('Manual path: dsh plugin --profile <name> add "' + String(doc.spec) + '"')
-      return { text: lines.join('\n') }
-    },
-  }), 'pwsh-run.update-tool')
-
-  /** 一条调用的实体；activeRuns 由注册处的 execute 在外面加减。 */
+  /** 一条调用的实体。 */
   const runScript = async (args, exec) => {
-    await waitForInstall()
     const requested = Number.isFinite(args?.timeoutMs) && args.timeoutMs > 0 ? Math.trunc(args.timeoutMs) : defaultTimeoutMs
     const key = sessionKey(exec)
     const workdir = typeof args?.workdir === 'string' && args.workdir.length > 0 ? args.workdir : undefined
@@ -522,14 +339,6 @@ export function apply(ctx, config) {
     for (const line of response?.warn ?? []) body.push('WARNING: ' + line)
     for (const line of response?.verbose ?? []) body.push('VERBOSE: ' + line)
     if (response?.sentinel === 'threw') body.push('[script threw]')
-    // 更新提示只在第一次查到新版本时挂一行，之后不再刷。自动更新关掉时给出可照做的命令，
-    // 打开时说清楚它自己会装——否则模型会把这个版本当成「需要人工干预」。
-    const fresh = checker?.announce
-    if (fresh !== undefined && autoUpdate === false) {
-      notes.push('[a newer pwsh-run release exists: ' + fresh.latest + ' (running ' + String(checker?.version ?? '?') +
-        '). Install it with dsh plugin --profile <name> add "' + fresh.spec + '". ' +
-        'Auto-update is off in this profile (config.autoUpdate: false).]')
-    }
     const text = [body.join('\n')]
       .concat(response?.err ?? [])
       .concat(response?.exceptions ?? [])
@@ -567,14 +376,7 @@ export function apply(ctx, config) {
       render: (_args, value) => [{ type: 'text', text: value.text }],
     },
     async execute(args, exec) {
-      // 自动更新与手动安装都要先看这个计数：热替换会 dispose 全部会话，
-      // 正跑着的脚本会被连人带马掐断。
-      activeRuns += 1
-      try {
-        return await runScript(args, exec)
-      } finally {
-        activeRuns -= 1
-      }
+      return await runScript(args, exec)
     },
   }), 'pwsh-run.tool')
-}
+}

package/wsl/custom-bash.mjs

@@ -22,6 +22,8 @@
  *                   最后才用包内自带的 wsl/llrun —— 显式安装的优先，包里那份只负责开箱可用。
  *                   取第一个可执行的；探测结果缓存，装好即生效，不必重启。
  *   fence           是否按 sandbox 权限档挂围栏，默认 true。
+ *   sshAgentSocket  WSL 侧的 ssh-agent socket 路径，默认 '~/.ssh/wsl2-ssh-agent.sock'；
+ *                   给 false 关掉这段探测。见下方「SSH agent」一节。
  *
  * 沙箱（2026-10-23）
  *   workspace-write / read-only 下经 `wsl/llrun` 起 bash：userns socket 掩蔽（docker 等）
@@ -40,6 +42,15 @@
  *   - POSIX 路径的 `workdir` 不能当 Windows 进程 cwd（spawn 直接失败）；
  *     有围栏时交给 llrun 的 `-C`（在 landlock 之后 chdir），无围栏时退化为命令内 `cd`。
  *   - 默认工作目录取自 workingDirectory 服务而非 header.cwd：会话中途切目录后 header 不更新。
+ *
+ * SSH agent
+ *   非交互 shell 不读 ~/.bashrc（那是交互式专属），所以用户终端里能用的
+ *   SSH_AUTH_SOCK 在这里天然是空的。而 WSLENV 转发也不可靠：Windows 侧的
+ *   变量要显式列进 WSLENV 才过界，且经 llrun 的 userns 之后仍然没有保证。
+ *   因此改成在脚本文本最前面插一段探测：socket 存在就 export，已设过则不动。
+ *   走 stdin 送进 `bash -s`，围栏内外是同一条路径，一处覆盖两种模式。
+ *   只 export 变量，不启动守护进程 —— 进程得由 systemd 用户单元之类的
+ *   围栏外机制维持，本工具无权也不该替用户起后台服务。
  */
 
 import { fileURLToPath } from 'node:url'
@@ -64,6 +75,30 @@ const DEFAULT_TIMEOUT_MS = 120000
 const DEFAULT_MAX_OUTPUT_BYTES = 64000
 const PROBE_TIMEOUT_MS = 8000
 
+/**
+ * 默认的 wsl2-ssh-agent socket（rupor-github/wsl-ssh-agent 的默认路径）。
+ * 用 $HOME 而不是展开后的绝对路径：脚本在 WSL 里跑，家目录以那边的为准。
+ */
+const DEFAULT_SSH_AGENT_SOCKET = '$HOME/.ssh/wsl2-ssh-agent.sock'
+
+/**
+ * 生成 agent 探测片段。返回空串表示不需要插入。
+ *
+ * 三件事同时成立才 export：调用方没有自己设 SSH_AUTH_SOCK、socket 确实存在、
+ * 并且是个 socket（`-S` 而不是 `-e`）—— 残留的普通文件不该被当成可用的 agent。
+ * 已设过就不覆盖：用户显式指定的优先级永远高于我们的猜测，哪怕它指错了，
+ * 也该由用户看到错误而不是被静默改到别处。
+ */
+export function sshAgentPreamble(socket) {
+  if (typeof socket !== 'string' || socket.length === 0) return ''
+  const quoted = '"' + socket.replaceAll('"', '\\"') + '"'
+  return [
+    'if [ -z "$SSH_AUTH_SOCK" ] && [ -S ' + quoted + ' ]; then',
+    '  export SSH_AUTH_SOCK=' + quoted,
+    'fi',
+  ].join('\n')
+}
+
 /**
  * 本文件同目录的 llrun，也就是随插件包一起发布的那份。
  * 从包加载时它是真的存在（bundle 把这一行指进 node_modules），
@@ -191,6 +226,13 @@ export function apply(ctx, config) {
   const configuredLlrun = typeof config?.llrunPath === 'string' && config.llrunPath.length > 0 ? config.llrunPath : undefined
   const llrunCandidates = configuredLlrun === undefined ? defaultLlrunCandidates() : [configuredLlrun]
   const fenceEnabled = config?.fence !== false
+  // 显式给 false 表示完全关掉；给字符串就用它；其余（含缺省）用默认 socket。
+  const sshAgentSocket = config?.sshAgentSocket === false
+    ? ''
+    : typeof config?.sshAgentSocket === 'string' && config.sshAgentSocket.length > 0
+      ? config.sshAgentSocket
+      : DEFAULT_SSH_AGENT_SOCKET
+  const agentPreamble = sshAgentPreamble(sshAgentSocket)
 
   /**
    * bash 解析：按 bashCandidates 顺序问 subprocess 服务，第一个解出来的胜出。
@@ -289,7 +331,8 @@ export function apply(ctx, config) {
       const needFence = fenceEnabled && mode !== 'danger-full-access'
 
       let argv
-      let script = args.command
+      // agent 探测排在用户脚本之前，两条路径共用同一段文本，围栏内外行为一致。
+      let script = agentPreamble.length > 0 ? agentPreamble + '\n' + args.command : args.command
       if (needFence) {
         const llrunPath = await resolveLlrun(shell, baseCwd)
         if (llrunPath === undefined) {
@@ -307,7 +350,9 @@ export function apply(ctx, config) {
         fenceArgs.push(shellQuote(workspace), '/bin/bash', '-s')
         argv = [shell, '-c', `exec ${llrunExecWord(llrunPath)} ${fenceArgs.join(' ')}`]
       } else {
-        if (posixDir !== undefined) script = `cd ${shellQuote(posixDir)} && ${args.command}`
+        // 这里要基于已经带上前置片段的 script 再包 cd，不能回到 args.command ——
+        // 否则带 workdir 的调用会静默丢掉 agent 探测。
+        if (posixDir !== undefined) script = `cd ${shellQuote(posixDir)} && ${script}`
         argv = [shell, '-s']
       }
 

package/plugin/auto-update.mjs

@@ -1,210 +0,0 @@
-/**
- * 无感自动更新：由插件自己把新版本装上，并让它就地生效。
- *
- * 为什么不能直接调 installBundle
- *   插件的 apply 与它起的定时器都跑在 HMR 的事务上下文里（AsyncLocalStorage）。
- *   在那个上下文里调 installBundle，pnpm 会跑完、磁盘也会换成目标版本，但随后的
- *   热重组会被 runExclusive 的嵌套检查拒掉（HMR transactions cannot be nested），
- *   留下「磁盘新版、进程旧版」这种最难看清的状态（实测）。先 executing.run(undefined, …)
- *   把上下文清空再调，HMR 才会真的重组合，并顺手把本插件自己替换掉
- *   （实测：改完文件后 137ms 新代码就生效，无需重启）。
- *
- * 为什么没有 HMR 就完全不装
- *   没有 HMR 的宿主上，装完磁盘是新的、进程里仍是旧的，而 bundle 行给不出新的 module URL，
- *   重启之前一直是「装上了但没生效」。这种自动毫无意义，反而让 pwsh_run_update 报出一个
- *   与真正在跑的代码不符的版本。此时退回只提示，由人决定何时升级、何时重启。
- *
- * 为什么不自己下载覆盖文件
- *   见 update-apply.mjs 的头注释：本插件是 profile 的 bundle 依赖，版本钉在
- *   package.json 与 pnpm-lock.yaml 里，绕开包管理器改文件会立刻让 lockfile 与磁盘不一致。
- *
- * 为什么必须等到「安静」才装
- *   热替换会执行本插件的 effect 清理函数，那里要 dispose 掉所有常驻 pwsh 会话。
- *   若此刻正有一条调用在跑，它会连带被掐断——脚本跑到一半、半截输出、会话状态全丢，
- *   与直接断电没有区别。所以安装前要问宿主「现在安静吗」，忙就整个推迟，
- *   而不是装完再说「可惜刚才那条被打断了」。
- *
- * 为什么要记住「上一次实际装到了哪个版本」
- *   pnpm 的 minimumReleaseAge 会让「请求 0.2.13、装到 0.2.12」成为正常结果。若不留这个记忆，
- *   下一轮还会请求 0.2.13、还会落回 0.2.12，被 plugin-manager 判 already-installed，
- *   退避爬到上限，永远如此。记住之后就能认出「这是冷却期，不是故障」，直接等到期。
- *
- * 为什么冷却期落地之后要把目标版本从「装过」里撤出来
- *   落到更旧的版本算成功，但它不是这次的目标：目标自己还要等窗口过去。若不当场撤掉，
- *   这个版本就再也不会被尝试，等于把这个进程的生命周期钉死在旧版本上。
- */
-
-import { installRelease, preflightInstall } from './update-apply.mjs'
-import { compareVersions } from './update-check.mjs'
-
-/** 首次检查前的等待：让启动流程先跑完，别跟它抢 pnpm。 */
-const FIRST_DELAY_MS = 90 * 1000
-/** 一轮正常节奏：与 UpdateChecker 的定时一致，失败时按下面的退避重排。 */
-const INTERVAL_MS = 12 * 60 * 60 * 1000
-const RETRY_BASE_MS = 5 * 60 * 1000
-const RETRY_MAX_MS = 2 * 60 * 60 * 1000
-/** 查出有新版但有调用正跑着：过一会儿再看一眼，别等到下一轮 12 小时。 */
-const BUSY_RETRY_MS = 3 * 60 * 1000
-/** 冷却期：pnpm 的窗口默认 24 小时，隔一小时再看一眼不浪费什么。 */
-const COOLDOWN_RETRY_MS = 60 * 60 * 1000
-
-/**
- * 在 HMR 事务之外装一个发布。
- *
- * @param ctx - 插件上下文，用来取 pluginManager 与 hmr。
- * @param spec - 钉住版本号的安装规格，例如 dsh-pwsh-plugin@0.2.13。
- * @param options - { requestId, log }。
- * @returns 与 installRelease 相同的结果对象，永不抛出。
- */
-export async function installReleaseLive(ctx, spec, options = {}) {
-  const manager = ctx?.get?.('pluginManager')
-  const hmr = ctx?.get?.('hmr')
-  // 回读装完的版本需要 profile 目录；读不到就只报 application，不编一个版本号出来。
-  const profileDir = ctx?.get?.('profileContext')?.dir
-  const base = { ...options, ...(typeof profileDir === 'string' ? { profileDir } : {}) }
-  if (hmr === undefined || typeof hmr?.executing?.run !== 'function') {
-    return await installRelease(manager, spec, { ...base, live: false })
-  }
-  // 上下文清空后 installBundle 自己会拿 runExclusive；装完 HMR 重组合，
-  // 本插件的模块被驱逐、新模块 import 进来重新 apply。
-  return await hmr.executing.run(undefined, () => installRelease(manager, spec, { ...base, live: true }))
-}
-
-/**
- * 宿主能不能就地换掉已加载的模块。判断与 installReleaseLive 用同一组条件，
- * 两处必须一致，否则会出现「循环以为装得上、安装却退回非 live」的错配。
- *
- * @param ctx - 插件上下文。
- * @returns 有可用的 HMR 服务时为 true。
- */
-function hmrIsLive(ctx) {
-  const hmr = ctx?.get?.('hmr')
-  return hmr !== undefined && typeof hmr?.executing?.run === 'function'
-}
-
-/**
- * 起一个自动更新循环：查到新版本就装上，失败按指数退避重试。
- *
- * @param ctx - 插件上下文。
- * @param checker - UpdateChecker 实例；它的 check() 重入安全，直接复用。
- * @param options - { log, firstDelayMs, intervalMs, retryBaseMs, retryMaxMs, cooldownRetryMs }。
- * @returns 停止函数；插件被卸载或热替换时由调用方停掉。
- */
-export function startAutoUpdate(ctx, checker, options = {}) {
-  const log = options.log ?? (() => undefined)
-  const firstDelayMs = options.firstDelayMs ?? FIRST_DELAY_MS
-  const intervalMs = options.intervalMs ?? INTERVAL_MS
-  const retryBaseMs = options.retryBaseMs ?? RETRY_BASE_MS
-  const retryMaxMs = options.retryMaxMs ?? RETRY_MAX_MS
-  const cooldownRetryMs = options.cooldownRetryMs ?? COOLDOWN_RETRY_MS
-
-  const installGate = options.installGate
-  const busyRetryMs = options.busyRetryMs ?? BUSY_RETRY_MS
-
-  /** 已经自动装过的版本：同一个版本装成功过就不再装第二次。 */
-  const attempted = new Set()
-  /** 上一次安装实际落到的版本：冷却期会让它与请求的版本不同，用来认出「不是故障」。 */
-  let lastInstalled
-  let timer
-  let stopped = false
-  let running = false
-  let failures = 0
-  /** 「忙，先不装」只记一次日志：每几分钟重复一行会把日志刷满。 */
-  let busyNoted = false
-
-  const schedule = (delayMs) => {
-    if (stopped) return
-    timer = setTimeout(tick, delayMs)
-    if (typeof timer.unref === 'function') timer.unref()
-  }
-
-  const tick = async () => {
-    if (stopped || running) return
-    running = true
-    let next = intervalMs
-    try {
-      const state = await checker.check()
-      if (state.state === 'available' && hmrIsLive(ctx) !== true) {
-        // 装上也换不掉正在跑的模块：留着提示那条路，别制造「装了但没生效」。
-        log('auto update: ' + state.latest + ' is available, but this host runs no HMR — leaving it for a manual upgrade')
-        failures = 0
-      } else if (state.state === 'available' && !attempted.has(state.latest) && installGate?.tryAcquire() !== false) {
-        try {
-          const doc = checker.document()
-          const spec = doc.spec
-          if (typeof spec === 'string' && spec.length > 0) {
-            // 装之前先问一句值不值得装，否则 already-installed 会以「失败」的姿态出现，
-            // 而它其实有几种含义完全不同的成因（别人装好了 / 发布忘了升版本 / 冷却期未过）。
-            const unnecessary = preflightInstall(ctx, checker, spec, lastInstalled === undefined ? {} : { cooled: lastInstalled })
-            if (unnecessary !== null) {
-              busyNoted = false
-              // 记下这个版本，别再排下一轮：这几种成因都不会在几分钟内自己好转。
-              // 冷却期例外——它是会到期的，所以单独按小时再看。
-              attempted.add(state.latest)
-              log('auto update: ' + state.latest + ' — ' + unnecessary.outcome + ': ' + unnecessary.text)
-              if (unnecessary.outcome === 'cooling-down') {
-                attempted.delete(state.latest)
-                next = cooldownRetryMs
-              } else if (unnecessary.ok === true) {
-                failures = 0
-              }
-              return
-            }
-            busyNoted = false
-            attempted.add(state.latest)
-            log('auto update: installing ' + state.latest + ' from ' + spec)
-            const outcome = await installReleaseLive(ctx, spec, { requestId: 'pwsh-run-auto-update', log })
-            log('auto update: ' + outcome.outcome + ' — ' + outcome.text)
-            if (outcome.installedVersion !== undefined) {
-              lastInstalled = outcome.installedVersion
-              // 落到更旧的版本是 pnpm 冷却期的正常结果，但目标版本还在窗口里：
-              // 撤掉这条记录，过一小时（窗口是 24 小时）再看，而不是等满 12 小时。
-              if (compareVersions(outcome.installedVersion, state.latest) < 0) {
-                attempted.delete(state.latest)
-                next = cooldownRetryMs
-              }
-            }
-            if (outcome.ok !== true) {
-              // 装失败要能重来：把记录撤掉，交给退避后的下一轮。
-              attempted.delete(state.latest)
-              failures += 1
-              next = Math.min(retryMaxMs, retryBaseMs * 2 ** (failures - 1))
-            } else {
-              failures = 0
-            }
-          }
-        } finally {
-          // 安装可能把本插件本身驱逐掉，于是这个 release 落在旧实例的闭包上，
-          // 只是把旧变量置回 false——新实例有它自己的闸门。
-          installGate?.release()
-        }
-      } else if (state.state === 'available' && !attempted.has(state.latest)) {
-        // 有新版，但此刻有调用在跑：热替换会掐断它。整轮推迟，几分钟后再看。
-        if (!busyNoted) {
-          busyNoted = true
-          log('auto update: ' + state.latest + ' is available, but a call is running — postponing the install until the session is idle')
-        }
-        next = busyRetryMs
-      } else if (state.state === 'failed') {
-        failures += 1
-        next = Math.min(retryMaxMs, retryBaseMs * 2 ** (failures - 1))
-      } else {
-        failures = 0
-      }
-    } catch (error) {
-      // check() 本身不抛；这里兜的是 installReleaseLive 之外的意外。
-      failures += 1
-      next = Math.min(retryMaxMs, retryBaseMs * 2 ** (failures - 1))
-      log('auto update: unexpected failure — ' + String(error?.message ?? error))
-    } finally {
-      running = false
-      schedule(next)
-    }
-  }
-
-  schedule(firstDelayMs)
-  return () => {
-    stopped = true
-    clearTimeout(timer)
-  }
-}