dsh-mobile-plugin 0.4.0 → 0.4.4

package/lib/sidecar-facade.cjs

@@ -3,14 +3,14 @@
 /**
  * SidecarFacade：宿主 ⇄ sidecar worker 的环回 HTTP 客户端 + 生命周期看守。
  *
- * fork worker、等 ready、把它的 stdout/stderr 转发到宿主 stderr（诊断只有这一条通道），
- * 之后按需 request('/status' | '/configure' | '/tunnel/send' | '/revoke-all')。
- * 两条上报通道都是「宿主必须立刻知道」的事：onDown（worker 意外退出，否则宿主的隧道/
- * 局域网快照会永远冻在临死前那一帧，比状态难看危险得多）与 onState（worker 在状态
- * 变化那一刻主动推的一帧，比 10s 轮询早得多）。
+ * fork worker、等 ready、把它的 stdout/stderr 转发到宿主 stderr（诊断只有这一条通道），之后
+ * 按需 request('/status' | '/configure' | '/tunnel/send' | '/revoke-all')。
  *
- * 刻意不做重试：request 超时就是超时，由调用方（sidecar-lifecycle）决定是否重启；
- * 在这里偷偷重试会把「隧道已死」拖成「偶尔能通」，反而更难诊断。
+ * 两条上报通道都是「宿主必须立刻知道」的事：onDown（worker 意外退出，否则隧道/局域网快照会
+ * 永远冻在临死前那一帧）、onState（worker 在状态变化那一刻主动推的一帧）。
+ *
+ * 刻意不做重试：超时就是超时，由调用方决定是否重启；偷偷重试会把「隧道已死」拖成
+ * 「偶尔能通」，更难诊断。
  */
 
 const http = require('node:http')
@@ -19,6 +19,15 @@ const { join } = require('node:path')
 
 const worker = join(__dirname, 'sidecar-facade-worker.cjs')
 
+/**
+ * `/configure` 的等待上限。
+ *
+ * 换中转地址时 worker 会**等新隧道真的注册上**再回包（顺序见 lib/relay/migrate.js）：注册
+ * 失败要撤销迁移、还要把错误一路回给手机上那一发请求。隧道自己的注册超时是 8s，所以这里
+ * 比它宽一截；超时了宿主拿到的是「facade 超时」而不是真正的原因，那句话在手机上没法用。
+ */
+const CONFIGURE_TIMEOUT_MS = 12_000
+
 class SidecarFacade {
   constructor(options) {
     this.parentPort = options.parentPort
@@ -120,7 +129,8 @@ class SidecarFacade {
   }
 
   async configure(config) {
-    return this.request('/configure', 'POST', config)
+    // 换地址那一发要等新隧道注册，比默认 5s 久（见 CONFIGURE_TIMEOUT_MS）。
+    return this.request('/configure', 'POST', config, CONFIGURE_TIMEOUT_MS)
   }
 
   async stop() {

package/lib/sidecar-lifecycle.cjs

@@ -3,21 +3,23 @@
 /**
  * sidecar 子进程的完整生命周期：起停、配置下发、自重启、健康轮询。
  *
- * 这些代码原本散在 apply() 里三段（状态变量、配置下发的串行化、自重启），中间还隔着
- * 一个 200 行的镜像推送调度器。它们共享同一批可变量（sidecarState / sidecarSnapshot /
- * restartInFlight / syncInFlight），拆到一处才看得清「谁改了什么」。
+ * 状态变量、配置下发的串行化、自重启共享同一批可变状态，拆到一处才看得清「谁改了什么」。
  *
- * 注意扩展名是 .cjs：包根声明 type=module，lib/ 下没有就近的 package.json，所以
- * lib/*.js 全是 ESM，只有 .cjs 是 CommonJS（同 sidecar-facade.cjs）。
+ * 扩展名是 .cjs：包根声明 type=module，lib/ 下没有就近的 package.json，所以 lib/*.js 全是
+ * ESM，只有 .cjs 是 CommonJS。
  *
- * ⚠️ `sidecar` 是**会被整体替换**的 let（自重启换掉 facade 实例），所以对外一律给
- * 取值器或 accessor，绝不能把实例本身传出去——传出去就是一份永远指向旧实例的快照。
+ * `sidecar` 是会被整体替换的 let（自重启换掉 facade 实例），所以对外一律给取值器，绝不能把
+ * 实例本身传出去。
+ *
+ * 每一次配置下发（`applySidecarConfig`）的成功失败都记进 `relay/apply-ledger.cjs` 的台账：
+ * 换中转地址失败时，手机端「运行状态」读的就是那一份（错误、时间与当时要切过去的地址）。
  */
 
 const path = require('node:path');
 const { randomBytes } = require('node:crypto');
 
 const { SidecarFacade } = require('./sidecar-facade.cjs');
+const applyLedger = require('./relay/apply-ledger.cjs');
 
 const HEALTH_POLL_INTERVAL_MS = 10000;
 
@@ -106,7 +108,16 @@ function createSidecarLifecycle(deps) {
     await resolveLanPort()
     const config = buildConfig(lanPortInUse())
     configuredLanPort = Number.isInteger(config.lanPort) ? config.lanPort : 0
-    sidecarSnapshot = await sidecar.configure(config)
+    // 失败必须落账（`/api/mobile/v1/relay/diagnostics` 的 `apply` 那一格）：所有下发都经过
+    // 这里 —— 手机改地址、电脑面板改地址、启动时那次 —— 而调用方几乎都 `.catch(() => …)`
+    // 掉。换地址失败的现场是「保存成功、然后永久离线」，台账是唯一能说清原因的地方。
+    try {
+      sidecarSnapshot = await sidecar.configure(config)
+    } catch (error) {
+      applyLedger.recordFailure(error, config.relayUrl)
+      throw error
+    }
+    applyLedger.recordSuccess()
     sidecarState = 'healthy'
     return sidecarSnapshot
   }
@@ -250,8 +261,8 @@ function createSidecarLifecycle(deps) {
      * `configure` 完的那个窗口里快照还是上一个号（或还没绑完），此刻去试绑刚下发的号必然
      * 失败——那是自己占着自己，不是被别人占了。只认快照的话，紧接着的第二次同步就会把这个
      * 号判成「被占」、换个内核随手给的端口写回 relay.json，监听也跟着挪走（`/api/relay/config`
-     * 改端口那条路由**一次会同步两遍**，第二遍正好落在这个窗口里；2026-10-11 真机实测，
-     * 落盘端口 18787→22779→33091→17079→28223 一路漂，手机里存的地址就是这么废的）。
+     * 改端口那条路由**一次会同步两遍**，第二遍正好落在这个窗口里，落盘端口一路漂，
+     * 手机里存的地址就是这么废的）。
      *
      * 代价照实说：真的被别的程序占着时，这里也认这个号。那没关系——worker 自己 bind 失败会
      * 退到内核给的空闲端口并按**实绑值**上报，对外报的地址（getAdvertisedLanPort）跟着它走。

package/lib/update-install.cjs

@@ -1,68 +1,24 @@
 'use strict';
 
 /**
- * 自己装新版：在 profile 里跑一次它**自己的**包管理器，把本插件换到指定版本。
+ * 自己装新版：在 profile 里跑一次它自己的包管理器，把本插件换到指定版本。
  *
- * ## 为什么不借道 DSH 插件市场
+ * 不借道 DSH 插件市场：更新分「查」（update-registry）和「装」，装该由插件自己完成，不该因为
+ * 另一个插件没装、太老或坏了就整个失效。
  *
- * 插件的更新分两步：**查**（线上最新是几，见 `update-registry.cjs`）和**装**（把新版本真的
- * 落到这台机器的 profile 里）。2026-10-11 之前「装」是请市场代劳的（打它的
- * `/dsh-market/api/v1/updates`，等它跑完 pnpm 再问结果）。用户的判断是：这件事插件应该
- * 自己完成，不该因为「另一个插件没装 / 太老 / 坏了」就整个失效。这里就是那一步。
+ * 不自己实现包管理，只驱动它：profile 的 pnpm-workspace.yaml 已经写好 node-linker、peer 等
+ * 关键设置，这里只「cd 到 profile 跑一句 pnpm add <包名>@<版本>」，不传布局类开关。三处必要
+ * 的开关：auto-install-peers=false（peer 是运行时注入的，npm 上没有）、CI=1（无终端），以及
+ * 撞上 pnpm「新发布先晾一会儿」时带 minimum-release-age=0 重试一次（那道策略查整份 lockfile，
+ * 别的插件刚发也会连累我们）。
  *
- * ## 关键：不自己实现包管理，只**驱动**它
+ * 包管理器优先用宿主发布的那个（profile 是宿主自带 pnpm 装的，PATH 上版本不同会
+ * ERR_PNPM_UNEXPECTED_STORE），找不到再退回 PATH。装之前先看有没有 agent 在跑；force 与 auto
+ * 都跳过这道闸、也都不等发布晾置期（2026-10-26 用户要求自动更新一检测到新版就立刻装，与面板
+ * 上那颗「强制更新」同一个口径），两者的区别只剩「没新版时装不装」。顺序上先答「有没有新版」，
+ * 没东西可装时不该拿「有对话在跑」挡在前面。
  *
- * profile 里装插件用的是 pnpm，而且 profile 自己的 `pnpm-workspace.yaml` 已经写好了所有
- * 关键设置（`node-linker=hoisted`、`auto-install-peers=false`、`minimum-release-age-exclude`
- * 那些按包放行的条目）。所以这里是「cd 到 profile，跑一句 `pnpm add <包名>@<版本>`」——
- * **不传布局类开关**，让它按 profile 的既有配置来，免得把别人的布局改写掉。市场那套
- * （`pnpm-compat.js` + `install.js`）几千行都在处理 pnpm 各版本的旗标拼写、hoist 恢复、
- * 镜像/超时/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`）一开始就带；平时不带，但**失败信息确实是这类策略时会带开关重试一次**
- *   —— 那道策略查的是**整份 lockfile**，别的插件刚发不久也会把整份锁文件判成「含未过期
- *   条目」，于是我们自己的更新整整一天都做不了，而原因跟我们这个包毫无关系（2026-10-11
- *   真机撞上的就是 `billion-context@0.1.192`）。市场那边对这种拒绝同样是带开关重试一次。
- * · `CI=1`：没有终端可交互。包管理器在无人值守的子进程里问问题是没法回答的。
- *
- * ## 装之前先看有没有 agent 在跑（但「有没有新版」排在它前面）
- *
- * 装是**就地替换插件文件**，正在干活的对话可能读到半个包。市场那条路有一道这样的闸
- * （`AGENTS_RUNNING`），这里也补上了 —— 判到有人跑就**不动盘**，如实报成「可再试」。
- *
- * 两档能跳过它：`force`（面板上的「强制更新」，用户明说「我知道，装吧」）与 `auto`（宿主
- * 每 10 分钟那一轮自动更新）。后者是有意的取舍：手机那边几乎一直有对话在跑，按着这道闸等，
- * 自动更新实际上永远轮不到 —— 而它的定义就是「没人看着也会发生」。
- *
- * `auto` **只**跳过这道闸：照样要有新版才装（不跳过下面那条判断），也不一开始就带发布时长
- * 开关（撞上再重试一次就够了）。把 `force` 那一档借给自动会在每 10 分钟把同一个版本重装
- * 一遍，那不是自动更新。
- *
- * 顺序上**先答「有没有新版」**：没东西可装时拿一句「有对话在跑」挡在前面是误导，用户会以为
- * 是那个原因，而真正的答案是「已经是最新」。
- *
- * ## 边界（照实说）
- *
- * · **只动 profile 的依赖树**（`pnpm add` 会顺手把 profile 的 `package.json` 里的依赖声明
- *   也更新掉——那正是「装上了」的凭据）。不碰仓库、不碰 `~/.dsh` 里别的东西。
- * · **找不到包管理器就如实失败**，不猜、不回退到「假装装好了」。桌面端由 GUI 拉起时 PATH
- *   往往很干净（LaunchServices 只给 `/usr/bin:/bin` 之类），所以这里照市场的做法补一组
- *   常见 bin 目录再找，见 `toolSearchDirs`。
- * · 装完**以盘上的版本号为准**：`installedVersion` 没变就是没装上，哪怕命令退出码是 0。
+ * 只动 profile 的依赖树；找不到包管理器就如实失败；装完以盘上版本号为准，退出码 0 不算装上。
  */
 
 const fs = require('node:fs');
@@ -288,6 +244,7 @@ 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 {boolean} [options.auto]           自动更新那一轮：同样跳过发布晾置期（见文件头）
  * @param {() => any} [options.beforeInstall] 真正跑包管理器**之前**调一次（外壳用它把正在跑的
  *   那一代复制进回退目录）。包管理器一跑就把旧的 store 目录清掉了，晚一步没得复制。
  * @returns {Promise<{installed, skipped, beforeVersion, installedVersion, source, command, output, failure}>}
@@ -297,6 +254,7 @@ async function installLatest({
   version,
   name = DEFAULT_NAME,
   force = false,
+  auto = false,
   timeoutMs = INSTALL_TIMEOUT_MS,
   env = process.env,
   platform = process.platform,
@@ -376,8 +334,11 @@ async function installLatest({
 
   const spec = `${name}@${version}`;
   const releaseAgeFlag = '--config.minimum-release-age=0';
+  // `auto` 与 `force` 一样一开始就带上开关：自动更新要「一检测到就装」，不该先被那道策略挡回来
+  // 再重试一遍（多等一轮、日志里多一条失败）。
+  const skipReleaseAge = force || auto;
   const args = picked.manager === 'pnpm'
-    ? ['add', spec, '--config.auto-install-peers=false', ...(force ? [releaseAgeFlag] : [])]
+    ? ['add', spec, '--config.auto-install-peers=false', ...(skipReleaseAge ? [releaseAgeFlag] : [])]
     : ['install', spec, '--no-audit', '--no-fund'];
   let command = [picked.manager, ...args].join(' ');
   onEvent({ phase: 'install-started', command, manager: picked.kind });
@@ -401,7 +362,7 @@ async function installLatest({
    * 重试一次只会把同一条错误再说一遍，还多花一次等待。
    */
   const releaseAgeLike = /MINIMUM_RELEASE_AGE|minimumReleaseAge|minimum-release-age|release age/i;
-  const retried = !result.ok && picked.manager === 'pnpm' && !force && releaseAgeLike.test(output);
+  const retried = !result.ok && picked.manager === 'pnpm' && !skipReleaseAge && releaseAgeLike.test(output);
   if (retried) {
     onEvent({ phase: 'release-age-retry' });
     result = await spawnAdd([releaseAgeFlag]);
@@ -467,7 +428,8 @@ async function installLatest({
  *
  * `force` 是**用户明说「我知道，装吧」**的那一挡（面板上那颗「强制更新」）：它同时跳过
  * 这道闸和「新发布先晾一会儿」的门槛，而且不管有没有新版都装一遍。`auto`（宿主那一轮自动
- * 更新）只跳过这道闸，其余照旧 —— 见文件头。
+ * 更新）跳过同样的两道闸，只是仍然「没新版就不动盘」—— 2026-10-26 用户要求自动更新一检测到
+ * 新版就立刻装，所以它不再等发布晾置期，见文件头。
  */
 async function installLatestIfNeeded(options = {}) {
   const { profileNodeModules, force = false, auto = false, name = DEFAULT_NAME, agents = null } = options;
@@ -491,7 +453,7 @@ async function installLatestIfNeeded(options = {}) {
   }
   const check = await checkForUpdate({ installedVersion: beforeVersion, source });
   // 「有没有新版」排在「有没有人在跑」**前面**：没东西可装的时候，拿一句「有对话在跑」挡住
-  // 真正的答案（已经是最新）是误导 —— 2026-10-11 真机上就是这么被绊了一下。
+  // 真正的答案（已经是最新）是误导。
   if (!force && !check.updateAvailable) {
     return {
       installed: false,

package/lib/update-registry.cjs

@@ -3,25 +3,13 @@
 /**
  * 「有没有新版」由插件自己回答：直接问 npm 注册表（`<registry>/<name>/latest`）。
  *
- * ## 为什么不再借道 DSH 插件市场
+ * 更新分「查」和「装」：查不需要市场（公开包一个 GET 就够），装由 `update-install.cjs` 在
+ * profile 里自己跑包管理器。绕开市场的理由很具体：市场没装、太老或坏了，「检查更新」就整个
+ * 答不出来。
  *
- * 更新其实分两件事：**查**（线上最新是几、这台机器上是几）和**装**（在 profile 里跑依赖
- * 安装、再把运行中的实现换掉）。装只能交给市场 —— 它握着 profile 的依赖树、版本核验与
- * 回滚点，插件自己再 shell 出去装一遍等于把那些抄一遍，而抄漏一处就是「装了个不是最新
- * 的版本」。但**查**不需要市场：这是个公开的 npm 包，一个 GET 就够了。
- *
- * 绕市场的代价很具体：市场（另一个插件）没装、太老或者坏了，「检查更新」就整个答不出来
- * —— 一个插件得另一个插件在场，才能告诉你自己有没有新版。所以这一格拿回来自己做。
- *
- * ## 边界（别把这条读成「更新彻底不依赖市场了」）
- *
- * · 这里**只查不装**：从头到尾不碰 profile、不碰市场、不写盘。装仍然是
- *   `/api/relay/update/apply` 那条路（外壳问市场 → 市场装 → 外壳就地换代）。
- * · `source`（npm / 本地 link / `file:` tgz）只有市场知道 —— 它读的是 profile 里的依赖
- *   声明。所以那一格传进来的是外壳**上次**问市场的结果；市场不在时如实为空，本模块
- *   **不会**为了这一格去敲市场。
- * · 判据是「线上版本严格大于盘上版本」。线上比盘上旧（回滚、本地构建跑在发布前面）一律
- *   报「没有新版」——「这次更新会降级」必须由版本比较判定，不能由「两个号不相等」判定。
+ * 边界：这里只查不装，不碰 profile、不写盘；`source`（npm / link / file:）只有市场知道，传
+ * 进来的是上次问到的结果，本模块不会为它去敲市场。判据是「线上版本严格大于盘上版本」，线上
+ * 更旧一律报没有新版——「这次更新会降级」必须由版本比较判定。
  */
 
 /** 默认注册表：官方源。私有镜像 / 测试用 `DSHM_NPM_REGISTRY` 覆盖。 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.4.0",
+  "version": "0.4.4",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (dsh 0.2.x, peers resolved by the host)",
   "license": "MIT",
   "engines": {

package/lib/auto-archive.cjs

@@ -1,98 +0,0 @@
-'use strict'
-
-const { unwrap } = require('./mobile/envelope.js')
-
-const ARCHIVE_AFTER_MS = 24 * 60 * 60 * 1000
-const SCAN_INTERVAL_MS = 12 * 60 * 60 * 1000
-
-function projectCounts(items) {
-  const counts = new Map()
-  for (const item of items) {
-    const cwd = typeof item?.cwd === 'string' ? item.cwd.trim() : ''
-    if (cwd) counts.set(cwd, (counts.get(cwd) || 0) + 1)
-  }
-  return counts
-}
-
-function archiveCandidates(items, now = Date.now()) {
-  const counts = projectCounts(items)
-  const cutoff = now - ARCHIVE_AFTER_MS
-  return items.filter(item => {
-    const cwd = typeof item?.cwd === 'string' ? item.cwd.trim() : ''
-    if (!cwd || (counts.get(cwd) || 0) <= 10) return false
-    if (item?.blank || item?.running || item?.sessionId === undefined) return false
-    return Number.isFinite(item.updatedAt) && item.updatedAt < cutoff
-  })
-}
-
-function loggerOf(ctx) {
-  return ctx?.logger && typeof ctx.logger === 'object' ? ctx.logger : undefined
-}
-
-function logFailure(ctx, sessionId, error) {
-  const logger = loggerOf(ctx)
-  const message = `automatic session archive failed for ${sessionId}: ${String(error?.message || error)}`
-  if (typeof logger?.warn === 'function') logger.warn(message)
-  else if (typeof logger?.error === 'function') logger.error(message)
-}
-
-async function scanAndArchive(ctx, now = Date.now()) {
-  const api = ctx?.apiProxy
-  const list = api?.sessions?.list
-  const archive = api?.workspace?.archiveSession
-  if (typeof list !== 'function' || typeof archive !== 'function') return { scanned: 0, archived: 0, failed: 0 }
-
-  const response = await list({ rpcId: 'dsh-mobile-plugin-auto-archive', method: 'session.list', payload: {} })
-  // 回执是 { result: { ok, value } } 信封：早先这里直接读 response.value，
-  // 而 list() 的回执根本不在那一层——这个定时任务从来没真正扫到过会话。
-  const listed = unwrap(response)
-  const items = (listed.value && listed.value.items) || []
-  const candidates = archiveCandidates(items, now)
-  let archived = 0
-  let failed = 0
-  for (const item of candidates) {
-    try {
-      const result = await archive({
-        rpcId: 'dsh-mobile-plugin-auto-archive',
-        method: 'workspace.archiveSession',
-        payload: { sessionId: item.sessionId },
-      })
-      if (result?.ok === false) throw new Error(result.error?.message || 'archive rejected')
-      archived += 1
-    } catch (error) {
-      failed += 1
-      logFailure(ctx, item.sessionId, error)
-    }
-  }
-  return { scanned: items.length, archived, failed }
-}
-
-function installAutoArchive(ctx) {
-  let disposed = false
-  let inFlight
-  const scan = () => {
-    if (disposed || inFlight) return inFlight
-    inFlight = Promise.resolve().then(() => scanAndArchive(ctx)).catch(error => {
-      logFailure(ctx, 'scan', error)
-      return { scanned: 0, archived: 0, failed: 1 }
-    }).finally(() => { inFlight = undefined })
-    return inFlight
-  }
-
-  void scan()
-  const timer = setInterval(() => { void scan() }, SCAN_INTERVAL_MS)
-  return () => {
-    if (disposed) return
-    disposed = true
-    clearInterval(timer)
-  }
-}
-
-module.exports = {
-  ARCHIVE_AFTER_MS,
-  SCAN_INTERVAL_MS,
-  archiveCandidates,
-  installAutoArchive,
-  projectCounts,
-  scanAndArchive,
-}