dsh-mobile-plugin 0.1.61 → 0.1.63

package/lib/routes/control-plane.js

@@ -30,7 +30,7 @@ const desktopHalf = require('../desktop-half-stats.cjs');
 // 「查有没有新版」与「装新版」这两格都归插件自己：查直接问 npm 注册表，装在 profile 里跑
 // 它自己的包管理器（见 `../update-registry.cjs` / `../update-install.cjs`）。不再借道市场。
 const { checkForUpdate } = require('../update-registry.cjs');
-const { installLatest, declaredSource } = require('../update-install.cjs');
+const { installLatestIfNeeded, declaredSource } = require('../update-install.cjs');
 const { clearCompletionForAllDevices, invalidateSessionList } = require('../mobile/session-cache.js');
 
 /** 一次 desktop-read 上报最多带多少个会话 id（防灌爆；客户端半边一次最多也就几个）。 */
@@ -395,6 +395,20 @@ function registerControlPlaneRoutes(deps) {
       return null
     }
   }
+  /**
+   * 取一个宿主服务，拿不到就当没有。
+   *
+   * 更新这条路要用两个：`profileContext`（宿主发布的包管理器调用方式，装的时候必须优先用它）
+   * 与 `agents`（「有对话在跑就别换插件文件」那道闸的判据）。宿主没提供某个服务时如实降级，
+   * **不许让路由因此抛错** —— 服务不存在时 `ctx.get` 本身可能就不在。
+   */
+  const hostService = key => {
+    try {
+      return ctx && typeof ctx.get === 'function' ? ctx.get(key) ?? null : null
+    } catch {
+      return null
+    }
+  }
   const runtimeUnavailable = { ok: false, error: { code: 'update_unavailable', message: '这一版没有可换代的外壳（插件是被直接挂载的），装完没法就地生效，所以这里不装：无头部署请 rsync 源码后重启' } }
   registerRoute({ kind: 'exact', path: '/api/relay/update/status', handler: localOnly('GET', async (_req, res) => {
     const runtime = pluginRuntime()
@@ -465,25 +479,21 @@ function registerControlPlaneRoutes(deps) {
       return sendJson(res, 500, { ok: false, error: { code: 'update_apply_failed', message: outcome.failure.message }, data: { ...outcome, status: snapshot } })
     }
 
-    let target = null
-    try {
-      const check = await checkForUpdate({
-        installedVersion: beforeVersion,
-        source: snapshot.marketResult?.source ?? null,
-      })
-      target = check.latestVersion
-      if (!check.updateAvailable && !force) {
-        answer({ skipped: true, state: 'succeeded', installedVersion: check.installedVersion ?? beforeVersion })
-        return sendJson(res, 200, { ok: true, data: { ...outcome, status: runtime.status() } })
-      }
-    } catch (error) {
-      answer({ failure: { code: 'update_check_failed', message: String(error?.message || error) } })
-      return sendJson(res, 500, { ok: false, error: { code: 'update_apply_failed', message: outcome.failure.message }, data: { ...outcome, status: snapshot } })
-    }
-
+    // 查一次（有没有新版）、可不可能被「有 agent 在跑」挡住、装不装，全在 `installLatestIfNeeded`
+    // 里一起判：面板那颗按钮与外壳的自动更新必须走同一套判定，否则会出现「手动说有新版、
+    // 自动说没有」这种最难查的偏差。
     let result
     try {
-      result = await installLatest({ profileNodeModules, version: target, force })
+      result = await installLatestIfNeeded({
+        profileNodeModules,
+        force,
+        // 宿主发布的包管理器调用方式（`{command, args, env?}`）。**必须优先用它**：PATH 上
+        // 那个 pnpm 的版本可能和 profile 的 store 对不上（实测 10.x 装 11.x 的 profile 直接
+        // `ERR_PNPM_UNEXPECTED_STORE`）。市场也是这么取的（`profileContext.packageManager`）。
+        packageManager: hostService('profileContext')?.packageManager ?? null,
+        // 「有对话在跑就先别换插件文件」那道闸的判据。force 由用户点按钮时显式带上。
+        agents: hostService('agents'),
+      })
     } catch (error) {
       result = { installed: false, installedVersion: beforeVersion, command: null, output: '', failure: { code: 'install_failed', message: String(error?.message || error) } }
     }
@@ -491,8 +501,12 @@ function registerControlPlaneRoutes(deps) {
     outcome.failure = result.failure ?? null
     outcome.command = result.command ?? null
     outcome.output = result.output ?? ''
+    outcome.retryable = result.retryable === true
+    // `skipped` 也要如实带出去：已经是最新那一条**不是失败**，面板照着它说「没有改动任何文件」。
+    outcome.skipped = result.skipped === true
+    outcome.state = result.installed || result.skipped ? 'succeeded' : 'failed'
     if (!result.installed) {
-      return sendJson(res, 200, { ok: false, data: { ...outcome, status: runtime.status() } })
+      return sendJson(res, 200, { ok: result.skipped === true, data: { ...outcome, check: result.check ?? null, status: runtime.status() } })
     }
 
     // 装上了才换代：换代码是外壳的事，失败要如实报（回滚由外壳负责，见 shell/runtime.js）。

package/lib/shell/updater.js

@@ -227,14 +227,22 @@ const TERMINAL = new Set(['succeeded', 'failed', 'cancelled', 'rolled-back'])
  * 装完了但盘上版本没变（市场报成功、文件没落），这里如实返回 `installed: false`，不让调用方
  * 以为换过代码 —— 「状态说成功、代码没换」是这个仓库吃过最贵的一次亏。
  */
-export async function installIfNeeded(base, { name = PACKAGE_NAME, force = false, onEvent = () => {}, now = Date.now } = {}) {
+export async function installIfNeeded(base, { name = PACKAGE_NAME, force = false, onEvent = () => {}, packageManager = () => null, agents = () => null, now = Date.now } = {}) {
   const before = installedVersion()
-  // 装归实现自己（2026-10-11 起）：盘上那一代里有 `update-install.cjs` 就走它。判定（查一次
-  // 有没有新版、`link:` 来源不碰）也一并交给它，别在这里抄第二份 —— 外壳与面板的按钮必须
-  // 是同一套判定，否则会出现「手动说有新版、自动说没有」。
+  // 装归实现自己（2026-10-11 起）：盘上那一代里有 `update-install.cjs` 就走它。判定（有没有
+  // 新版、`link:` 来源不碰、有 agent 在跑就先别换文件）也一并交给它，别在这里抄第二份 ——
+  // 外壳的自动更新与面板那颗按钮必须是同一套判定，否则会出现「手动说有新版、自动说没有」。
   const selfInstall = await installedInstaller()
   if (selfInstall) {
-    const outcome = await selfInstall({ profileNodeModules: profileNodeModules(), force, onEvent })
+    const outcome = await selfInstall({
+      profileNodeModules: profileNodeModules(),
+      force,
+      onEvent,
+      // 宿主发布的包管理器（优先用它装）与 agents 服务（那道闸的判据）都从外壳这一层透下去：
+      // 实现在代里，它没有宿主 ctx，只有外壳有。
+      packageManager: packageManager(),
+      agents: agents(),
+    })
     return {
       installed: outcome.installed === true,
       skipped: outcome.skipped === true,
@@ -245,7 +253,8 @@ export async function installIfNeeded(base, { name = PACKAGE_NAME, force = false
       restartRequired: false,
       refreshRequired: false,
       failure: outcome.failure ?? null,
-      retryable: false,
+      // 「有 agent 在跑」这类是「现在不行」，下个 tick 再试，不是坏了。
+      retryable: outcome.retryable === true,
       command: outcome.command ?? null,
       check: outcome.check ?? null,
     }

package/lib/update-install.cjs

@@ -20,16 +20,34 @@
  * 镜像/超时/Windows shim 这些边角；这里刻意**只做我们自己这条路上必须的那两三个开关**，
  * 剩下的交给 profile 自己的配置。
  *
+ * ## 用哪个包管理器：**宿主给的那个优先**
+ *
+ * 2026-10-11 真机踩到：这台机器 PATH 上的 pnpm 是 10.x（store v10），而 profile 是**宿主
+ * 自带的** pnpm 11.x（store v11）装的，拿 PATH 那个去装直接 `ERR_PNPM_UNEXPECTED_STORE`。
+ * 所以顺序是「宿主发布的调用方式 → PATH 上的 pnpm → npm」，见 `normalizeInvocation`。
+ *
  * ## 三个开关，每个都有理由
  *
  * · `--config.auto-install-peers=false`：本插件的 peer 里有一串 `@deepseek-ai/*`
  *   （`cordis`、`dsh-tools`、`dsh-client-runtime`…），它们是 **DSH 运行时注入的、npm 上
  *   根本没有**。pnpm 8 起 `auto-install-peers` 默认开，会去 npm 上拉这些 peer 然后 404。
  *   profile 里通常已经关掉了，但那是市场帮它写的 —— 换台机器不一定有，所以这里显式带上。
- * · `--config.minimum-release-age=0`：**只在强制更新时**带。pnpm 的「新发布先晾一会儿」
- *   门槛会把刚发的版本挡在外面，`force` 就是「我知道，装它」。
+ * · `--config.minimum-release-age=0`：**撞上 pnpm 的「新发布先晾一会儿」策略时才带**。
+ *   强制更新（`force`）一开始就带；平时不带，但**失败信息确实是这类策略时会带开关重试一次**
+ *   —— 那道策略查的是**整份 lockfile**，别的插件刚发不久也会把整份锁文件判成「含未过期
+ *   条目」，于是我们自己的更新整整一天都做不了，而原因跟我们这个包毫无关系（2026-10-11
+ *   真机撞上的就是 `billion-context@0.1.192`）。市场那边对这种拒绝同样是带开关重试一次。
  * · `CI=1`：没有终端可交互。包管理器在无人值守的子进程里问问题是没法回答的。
  *
+ * ## 装之前先看有没有 agent 在跑（但「有没有新版」排在它前面）
+ *
+ * 装是**就地替换插件文件**，正在干活的对话可能读到半个包。市场那条路有一道这样的闸
+ * （`AGENTS_RUNNING`），这里也补上了 —— 判到有人跑就**不动盘**，如实报成「可再试」。
+ * `force`（面板上的「强制更新」）是用户明说「我知道，装吧」的那一挡，会跳过它。
+ *
+ * 顺序上**先答「有没有新版」**：没东西可装时拿一句「有对话在跑」挡在前面是误导，用户会以为
+ * 是那个原因，而真正的答案是「已经是最新」。
+ *
  * ## 边界（照实说）
  *
  * · **只动 profile 的依赖树**（`pnpm add` 会顺手把 profile 的 `package.json` 里的依赖声明
@@ -138,7 +156,56 @@ function declaredSource(profileDir, name = DEFAULT_NAME) {
   }
 }
 
-/** 跑一条命令，收 stdout+stderr 的尾巴。超时或非零退出码都如实带出来。 */function run(command, args, { cwd, env, timeoutMs, spawnImpl = spawn }) {
+/**
+ * 宿主**发布出来**的包管理器调用方式（DSH 桌面版把它挂在 `profileContext.packageManager`
+ * 上，形状 `{command, args, env?}`）。
+ *
+ * 为什么非得用它、而不是 PATH 上那个 pnpm：桌面版由 GUI 拉起时 PATH 很干净，而且**版本
+ * 可能对不上** —— 实测这台机器上 PATH 的 pnpm 是 10.x（store v10），而 profile 是宿主自带的
+ * pnpm 11.x（store v11）装的，用它装会直接 `ERR_PNPM_UNEXPECTED_STORE`。市场那边也是
+ * 「宿主给的那个优先，找不到才退回 PATH 和 corepack」（`dsh-cli.js` 的 `probePnpm`）。
+ *
+ * 形状有一格不对就整个丢掉（半份调用等于仍然跑不起来的工具）；`env` 只收字符串值。
+ */
+function normalizeInvocation(published) {
+  if (published === null || typeof published !== 'object' || Array.isArray(published)) return null;
+  const { command, args, env } = published;
+  if (typeof command !== 'string' || command.trim() === '') return null;
+  if (!Array.isArray(args) || args.some(arg => typeof arg !== 'string')) return null;
+  const merged = {};
+  for (const [key, value] of Object.entries(env ?? {})) {
+    if (typeof value === 'string') merged[key] = value;
+  }
+  return { command: command.trim(), args: [...args], env: merged };
+}
+
+/**
+ * 此刻正在跑的 agent（`status === 'running'` 的那些）。
+ *
+ * 判据与市场那份（`dshmarket` 的 `agents.js`）逐字一致：`agents.list()` 里 `status` 正好是
+ * `'running'` 的才算，列表读不到或抛错一律当「没有」—— 守卫宁可放过，也不能因为读不到状态
+ * 就把更新整个锁死。**不排除调用者自己**：这正是「有对话在跑就别换插件文件」的意思。
+ */
+function runningAgentIds(agents) {
+  if (agents === null || agents === undefined) return [];
+  let listed;
+  try {
+    listed = typeof agents.list === 'function' ? agents.list() : null;
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(listed)) return [];
+  const ids = [];
+  for (const agent of listed) {
+    if (agent === null || typeof agent !== 'object' || agent.status !== 'running') continue;
+    const id = typeof agent.id === 'string' && agent.id !== '' ? agent.id : 'agent';
+    if (!ids.includes(id)) ids.push(id);
+  }
+  return ids;
+}
+
+/** 跑一条命令，收 stdout+stderr 的尾巴。超时或非零退出码都如实带出来。 */
+function run(command, args, { cwd, env, timeoutMs, spawnImpl = spawn }) {
   return new Promise(resolve => {
     let child;
     try {
@@ -191,15 +258,16 @@ async function installLatest({
   platform = process.platform,
   // 去哪儿找包管理器。默认那组见 `toolSearchDirs`；注入只为测试。
   dirs = null,
+  // 宿主发布的调用方式（`profileContext.packageManager`）。**优先用它**，理由见
+  // `normalizeInvocation` 的文件注释（版本对不上会把 profile 的 store 认错）。
+  packageManager = null,
   onEvent = () => {},
 } = {}) {
   const beforeVersion = installedVersion(profileNodeModules, name);
   const profileDir = path.dirname(profileNodeModules);
   const searchDirs = dirs ?? toolSearchDirs({ platform, env });
-  const pnpm = resolveExecutable('pnpm', searchDirs, { platform, env });
-  const npm = pnpm ? null : resolveExecutable('npm', searchDirs, { platform, env });
-  const manager = pnpm ? 'pnpm' : npm ? 'npm' : null;
-  const binary = pnpm || npm;
+  const hostInvocation = normalizeInvocation(packageManager);
+  const childEnv = spawnEnv(searchDirs, env);
 
   const fail = (code, message) => ({
     installed: false,
@@ -212,11 +280,36 @@ async function installLatest({
     failure: { code, message },
   });
 
-  if (!binary) {
+  /**
+   * 挑一个能用的包管理器：**宿主给的那个先试**（探一次 `--version`，跑不起来就当没有），
+   * 之后才是 PATH 上的 pnpm / npm。返回 `{command, prefix, manager, kind}`。
+   */
+  async function pickManager() {
+    if (hostInvocation) {
+      const probe = await run(hostInvocation.command, [...hostInvocation.args, '--version'], {
+        cwd: profileDir,
+        env: { ...childEnv, ...hostInvocation.env },
+        timeoutMs: 20000,
+      });
+      if (probe.ok) {
+        return { command: hostInvocation.command, prefix: hostInvocation.args, manager: 'pnpm', kind: 'host', env: hostInvocation.env };
+      }
+      onEvent({ phase: 'host-manager-unusable', output: probe.output });
+    }
+    const pnpm = resolveExecutable('pnpm', searchDirs, { platform, env });
+    if (pnpm) return { command: pnpm, prefix: [], manager: 'pnpm', kind: 'path', env: {} };
+    const npm = resolveExecutable('npm', searchDirs, { platform, env });
+    if (npm) return { command: npm, prefix: [], manager: 'npm', kind: 'path', env: {} };
+    return null;
+  }
+
+  const picked = await pickManager();
+  if (!picked) {
     return fail(
       'PACKAGE_MANAGER_MISSING',
-      '这台机器上找不到 pnpm / npm，装不了新版。装一个 pnpm（或 npm）之后重试；' +
-        '插件不会自己去下载解包 —— 那等于把包管理器的活抄一遍，抄漏一处就是装出半个包。',
+      '这台机器上找不到能用的包管理器（宿主没发布、PATH 上也没有 pnpm / npm），装不了新版。' +
+        '装一个 pnpm（或 npm）之后重试；插件不会自己去下载解包 —— 那等于把包管理器的活抄一遍，' +
+        '抄漏一处就是装出半个包。',
     );
   }
 
@@ -230,13 +323,39 @@ async function installLatest({
   }
 
   const spec = `${name}@${version}`;
-  const args = manager === 'pnpm'
-    ? ['add', spec, '--config.auto-install-peers=false', ...(force ? ['--config.minimum-release-age=0'] : [])]
+  const releaseAgeFlag = '--config.minimum-release-age=0';
+  const args = picked.manager === 'pnpm'
+    ? ['add', spec, '--config.auto-install-peers=false', ...(force ? [releaseAgeFlag] : [])]
     : ['install', spec, '--no-audit', '--no-fund'];
-  const command = [manager, ...args].join(' ');
-  onEvent({ phase: 'install-started', command });
+  let command = [picked.manager, ...args].join(' ');
+  onEvent({ phase: 'install-started', command, manager: picked.kind });
 
-  const result = await run(binary, args, { cwd: profileDir, env: spawnEnv(searchDirs, env), timeoutMs });
+  const spawnAdd = extra => run(picked.command, [...picked.prefix, ...args, ...extra], {
+    cwd: profileDir,
+    env: { ...childEnv, ...picked.env },
+    timeoutMs,
+  });
+  let result = await spawnAdd([]);
+  let output = result.output;
+  /**
+   * 撞上 pnpm 的「新发布先晾一会儿」策略：**带上开关重试一次**。
+   *
+   * 为什么非重试不可：那道策略查的是**整份 lockfile**，不是我们要装的这个包。这台机器上
+   * 实测过一次 —— 另一个插件（`billion-context@0.1.192`）刚发不久，整份 lockfile 就被判
+   * 「含未过期的条目」而拒绝，于是我们自己的更新整整一天都做不了，而原因跟我们这个包毫无
+   * 关系。市场那边对这种拒绝也是带开关重试一次（`RELEASE_AGE_OVERRIDE`）。
+   *
+   * 只在**第一次没带开关**、且失败信息确实是这类策略时才重试：别的失败（网络、权限、盘满）
+   * 重试一次只会把同一条错误再说一遍，还多花一次等待。
+   */
+  const releaseAgeLike = /MINIMUM_RELEASE_AGE|minimumReleaseAge|minimum-release-age|release age/i;
+  const retried = !result.ok && picked.manager === 'pnpm' && !force && releaseAgeLike.test(output);
+  if (retried) {
+    onEvent({ phase: 'release-age-retry' });
+    result = await spawnAdd([releaseAgeFlag]);
+    command = [picked.manager, ...args, releaseAgeFlag].join(' ');
+    output = `${output}\n--- 撞上 pnpm 的发布时长策略，带上 ${releaseAgeFlag} 重试一次 ---\n${result.output}`;
+  }
   const after = installedVersion(profileNodeModules, name);
   if (!result.ok) {
     return {
@@ -246,7 +365,9 @@ async function installLatest({
       installedVersion: after,
       source: declaredSource(profileDir, name),
       command,
-      output: result.output,
+      manager: picked.kind,
+      retried,
+      output,
       // 超时与「真的失败了」分开说：前者可以再试，后者多半要看输出。
       failure: {
         code: result.code === null ? 'INSTALL_ABORTED' : 'INSTALL_FAILED',
@@ -263,7 +384,9 @@ async function installLatest({
     installedVersion: after,
     source: declaredSource(profileDir, name),
     command,
-    output: result.output,
+    manager: picked.kind,
+    retried,
+    output,
     failure: changed
       ? null
       : { code: 'VERSION_UNCHANGED', message: `${command} 跑完了，但盘上还是 ${after ?? '读不到版本'}，这一次不算数` },
@@ -271,16 +394,27 @@ async function installLatest({
 }
 
 /**
- * 「让我变成最新」：先查一次，再决定装不装。
+ * 「让我变成最新」：先看有没有人在干活，再查一次，最后决定装不装。
  *
  * 面板那颗按钮**与外壳的自动更新**都打这个入口 —— 两处走同一套判定，免得出现「手动说有
  * 新版、自动说没有」这种最难查的偏差。已经是最新（`force` 为假）就什么都不做、如实报
  * `skipped`。
+ *
+ * ## 为什么装之前先看有没有 agent 在跑
+ *
+ * 装会**就地换掉插件文件**（profile 里那一份），而正在干活的对话可能正好在装配/读取插件
+ * 目录 —— 换到一半就是「读到半个包」。市场那条路也有同一道闸（`AGENTS_RUNNING`），这条是
+ * 把它搬到插件自己这条路上来。判到有人跑就**不动盘**，如实报成「可再试」，下个 tick 再来。
+ *
+ * `force` 是**用户明说「我知道，装吧」**的那一挡（面板上那颗「强制更新」）：它同时跳过
+ * 这道闸和「新发布先晾一会儿」的门槛。自动更新永远不带 force。
  */
 async function installLatestIfNeeded(options = {}) {
-  const { profileNodeModules, force = false, name = DEFAULT_NAME } = options;
+  const { profileNodeModules, force = false, name = DEFAULT_NAME, agents = null } = options;
   const beforeVersion = installedVersion(profileNodeModules, name);
   const check = await checkForUpdate({ installedVersion: beforeVersion, source: declaredSource(path.dirname(profileNodeModules), name) });
+  // 「有没有新版」排在「有没有人在跑」**前面**：没东西可装的时候，拿一句「有对话在跑」挡住
+  // 真正的答案（已经是最新）是误导 —— 2026-10-11 真机上就是这么被绊了一下。
   if (!force && !check.updateAvailable) {
     return {
       installed: false,
@@ -294,6 +428,30 @@ async function installLatestIfNeeded(options = {}) {
       check,
     };
   }
+  if (!force) {
+    const running = runningAgentIds(agents);
+    if (running.length > 0) {
+      return {
+        installed: false,
+        skipped: false,
+        beforeVersion,
+        installedVersion: beforeVersion,
+        source: check.source,
+        command: null,
+        output: '',
+        runningAgents: running,
+        retryable: true,
+        check,
+        failure: {
+          code: 'AGENTS_RUNNING',
+          message:
+            `有 ${running.length} 个 agent 正在运行（${running.slice(0, 4).join(', ')}）。` +
+            '装新版会就地替换插件文件，正在干活的对话可能读到半个包；等它完成（或先取消）再更新。' +
+            '确定要现在装的话，点面板上的「强制更新」。',
+        },
+      };
+    }
+  }
   const result = await installLatest({ ...options, version: check.latestVersion });
   return { ...result, check };
 }
@@ -305,6 +463,8 @@ module.exports = {
   declaredSource,
   toolSearchDirs,
   resolveExecutable,
+  normalizeInvocation,
+  runningAgentIds,
   DEFAULT_NAME,
   INSTALL_TIMEOUT_MS,
   OUTPUT_TAIL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.1.61",
+  "version": "0.1.63",
   "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",