dsh-mobile-plugin 0.1.100 → 0.2.1

package/lib/shell/updater.js

@@ -227,16 +227,20 @@ 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, beforeInstall = null, now = Date.now } = {}) {
+export async function installIfNeeded(base, { name = PACKAGE_NAME, force = false, auto = false, onEvent = () => {}, packageManager = () => null, agents = () => null, beforeInstall = null, now = Date.now } = {}) {
   const before = installedVersion()
   // 装归实现自己（2026-10-11 起）：盘上那一代里有 `update-install.cjs` 就走它。判定（有没有
   // 新版、`link:` 来源不碰、有 agent 在跑就先别换文件）也一并交给它，别在这里抄第二份 ——
   // 外壳的自动更新与面板那颗按钮必须是同一套判定，否则会出现「手动说有新版、自动说没有」。
+  //
+  // `auto` 也透下去：自动那一轮跳过「有对话在跑就先别装」那道闸（2026-10-25 用户拍板的取舍，
+  // 见 `update-install.cjs` 文件头），但没有新版时它照样什么都不做。
   const selfInstall = await installedInstaller()
   if (selfInstall) {
     const outcome = await selfInstall({
       profileNodeModules: profileNodeModules(),
       force,
+      auto,
       onEvent,
       // 宿主发布的包管理器（优先用它装）与 agents 服务（那道闸的判据）都从外壳这一层透下去：
       // 实现在代里，它没有宿主 ctx，只有外壳有。
@@ -262,6 +266,8 @@ export async function installIfNeeded(base, { name = PACKAGE_NAME, force = false
     }
   }
   const check = await checkUpdate(base, name, { force })
+  // 兜底这条路（盘上那一代还没有自装模块）**不认 `auto`**：市场接口只有 `force` 这一档，
+  // 而把 `force` 借给自动会连「有没有新版」一起跳过。宁可让它暂时还按老规矩在对话结束后装。
   if (check.source !== null && !updatableSource(check.source)) {
     // 本地 link / file: 装的：市场不会碰它（见 updatableSource）。如实返回，别去试。
     return {
@@ -344,6 +350,7 @@ async function runUpdate({ runtime, base, hostService = () => null, updateState,
   try {
     outcome = await installIfNeeded(base, {
       force,
+      auto,
       beforeInstall,
       packageManager: () => hostService('profileContext')?.packageManager ?? null,
       agents: () => hostService('agents'),
@@ -375,18 +382,37 @@ async function runUpdate({ runtime, base, hostService = () => null, updateState,
   let swapped = false
   let swapFailure = null
   let deferred = false
+  /**
+   * 换代之后自检没过、外壳自己退回去了。
+   *
+   * 判据与动作都在 `runtime.js`（它才知道新版到底装起来了没有），这里只把那条**已经发生
+   * 过的事实**抄进这一轮的账。手机端不按回滚 —— 装坏的后果正是 App 连不上，那时候它按不了
+   * 任何东西 —— 它只用这条记录在**下一次连上之后**如实显示「上次装失败了，已退回 X」。
+   */
+  let rollback = null
   if (outcome.installed === true || newerOnDisk) {
     const attempt = await swapTo(runtime, disk ?? runningBefore, { auto, log })
     swapped = attempt.swapped
     swapFailure = attempt.failure
     deferred = attempt.deferred === true
+    rollback = attempt.rollback ?? null
   }
+  const rolledBack = Boolean(rollback && rollback.ok)
   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,
+    state: rolledBack
+      ? 'rolled-back'
+      : swapFailure ? 'installed-not-swapped' : (outcome.state ?? (outcome.installed || outcome.skipped ? 'succeeded' : 'failed')),
+    // 退回去了的话，真正失败的原因是自检那句话，而不是「换代码抛错」那个笼统说法。
+    failure: rolledBack
+      ? { code: 'self_check_failed', message: rollback.reason }
+      : (swapFailure ?? outcome.failure ?? null),
+    /** 装上了、但新版没通过自检，于是外壳自己退回了上一代。 */
+    rolledBack,
+    /** 退回之后跑着的版本（退成功才有）。 */
+    runningAfterRollback: rolledBack ? (rollback.toVersion ?? null) : null,
     // 换代由外壳就地做，市场那套「装完要重启」在本项目一律不照做。只为如实上报。
     restartRequired: false,
     refreshRequired: false,
@@ -422,14 +448,29 @@ async function swapTo(runtime, target, { auto = false, log = () => {} } = {}) {
     }
   }
   swapAttempts.set(key, Math.max(tried, 1))
+  let rollback = null
   try {
     const status = await runtime.reload()
     swapAttempts.delete(key)
+    // 外壳把「装起来了但自检没过、于是自己退回去」记在 `lastRollback` 上，而不是抛错
+    // （它退成功了，进程还活着）。这里把它捞出来，交给这一轮的账 —— 手机端要读的就是它。
+    rollback = status?.lastRollback ?? null
+    if (rollback && rollback.ok) {
+      log('warn', 'dsh-mobile-plugin: 新版自检没过，已退回 %s：%s', rollback.toVersion, rollback.reason)
+      return {
+        swapped: false,
+        rollback,
+        failure: { code: 'self_check_failed', message: rollback.reason },
+      }
+    }
     log('info', 'dsh-mobile-plugin: 已就地换到 %s（无需重启 DSH）', status?.version ?? key)
     return { swapped: true, status }
   } catch (error) {
+    // 新版装载直接抛错：runtime 已经按老规矩回滚过一代了，那条回滚也记在 `lastRollback`。
+    try { rollback = runtime.status()?.lastRollback ?? null } catch { rollback = null }
     return {
       swapped: false,
+      rollback,
       failure: { code: 'swap_failed', message: `新版已经装到盘上（${key}），但换代码没成：${String(error?.message || error)}` },
     }
   }

package/lib/sidecar-facade-worker.cjs

@@ -26,6 +26,11 @@ const { lanUrls } = require('./relay/lan-network.cjs')
 const core = require('./relay/core.js')
 const { createReconnectScheduler } = require('./reconnect-scheduler.cjs')
 const { isMirrorSnapshotFresh } = require('./mirror-snapshot.cjs')
+// 凭据库在这个进程里**只读**（§3.7）：写盘只有宿主主进程一家。签发与吊销都经 IPC 交给它，
+// 本地这份按文件指纹重载 —— 两个进程各持一份内存副本、各自整份覆写，后写的赢，于是
+// 「经中转配上的手机回局域网 401」「吊销被回滚」这两条必然出现。
+const credentials = require('./shared/credentials-entry.js').credentialsEntry()
+if (typeof credentials.setReadOnly === 'function') credentials.setReadOnly(true)
 
 const parentPort = Number(process.env.DSH_SIDECAR_PARENT_PORT)
 const token = process.env.DSH_SIDECAR_TOKEN
@@ -104,6 +109,28 @@ class BodyTooLarge extends Error {}
  * 留 64KB 余量给帧头。推得再大也只是这一次 413，隧道安然无恙。
  */
 const TUNNEL_SEND_MAX_BODY = 8 * 1024 * 1024 - 64 * 1024
+
+/**
+ * 推给中转的那一份镜像：只留中转真的会读的字段。
+ *
+ * 桌面推上来的整份载荷里有四块：`sessions`、`workspaces`、`messages`、`stats`/`models`。
+ * 中转（`server/relay/rust/src/mirror.rs` 的 `remember`）只落**前两块**，另外三块
+ * 解析完就丢——它只解决「宿主不在线时手机还看得见清单」，会话正文有自己那条
+ * `/session/messages` 通道。而正文快照恰好是最大的一块：实测一个 200 条消息的会话
+ * 快照约 58KB，而它在每个会话事件上都会被重推一次。
+ *
+ * 所以**上隧道的那一份裁掉三块，本地快照（localSnapshot）照旧留全份**——局域网直连的
+ * 手机走 `snapshotRead` 读的就是本地那份，裁了它等于把读取隔离一起砍掉。
+ *
+ * 裁字段而不是改推送策略：宿主那侧「推什么、什么时候推」一个字都不用改，两侧版本
+ * 不必同时上线（老 worker + 新宿主也照旧工作，只是白推；新 worker + 老宿主也照旧）。
+ */
+function frameForTunnel(body) {
+  if (!body || typeof body !== 'object') return { kind: 'raw', data: body }
+  if (body.kind !== 'sync') return body
+  const { messages, stats, models, ...rest } = body
+  return rest
+}
 // /configure 只送 relay.json 那几十个字段，给 64KB 绰绰有余；放宽只会让误用更难发现。
 const CONFIGURE_MAX_BODY = 64 * 1024
 function readBody(req, limit) {
@@ -146,6 +173,12 @@ function upstream() { return `http://127.0.0.1:${config.upstreamPort}` }
 // 读取隔离：把移动端高频读请求（sessions/workspaces/messages/stats）从本地快照直接回，
 // 不再打扰主进程。快照缺失或路径不在清单内时返回 null → 调用方回源主进程。
 function snapshotRead(info) {
+  // **协议 v2 的会话不走这条捷径**：这里直接回序列化好的 JSON，绕开了主进程的守卫 ——
+  // 请求信封没验、响应也没封。表现是「加密会话的高频读（列表 / 工作区 / 消息 / 统计）
+  // 全程明文过中转」，而且静默（App 收到明文只是降级，不报错）。回 null 让调用方回源
+  // 主进程，那条路有 `rev` 条件刷新，稳态只回几十字节，比这里回 38KB 还省。
+  const proto = info && info.headers ? String(info.headers['x-dsh-proto'] || info.headers['X-Dsh-Proto'] || '') : ''
+  if (proto.trim() === '2') return null
   // 镜像只在中转连着时才会有新版本推来（原因见 mirror-snapshot.cjs 的说明）：冻结的快照必须
   // 回源主进程，否则中转一断、局域网仍健康时，新建的会话/工作区在 App 里永远不出现。
   if (!isMirrorSnapshotFresh(localSnapshot)) return null
@@ -160,6 +193,16 @@ function snapshotRead(info) {
     : null
   if (!body || typeof body !== 'object' || body.ok !== true) return null
   if (pathname === '/api/mobile/v1/session/messages') {
+    // **按内容裁的入口窗口（`thin=1`）不走这条捷径**：镜像里存的是一份完整窗口
+    // （最多 200 条消息），对着一轮跑过上百步的会话，它照样可能整条挤掉用户那句话 ——
+    // 那正是「进对话只剩 AI 的半轮」这个缺陷本身。裁剪是主进程按轮算的，这里回 null 让它
+    // 回源；入口那一发进对话只发一次，不是轮询。
+    if (url.searchParams.get('thin') === '1') return null
+    // 带 beforeSeq 的是**翻页**（往上翻历史 / 补取某一轮的过程明细）：镜像只有尾部一份窗口，
+    // 它答不了「比这条更早」——早年这里直接回整份，调用方按 seq 自己过滤，看着能用，
+    // 但只要一轮比镜像窗口还长，补取就会在原地转三圈什么也拿不到。回源主进程。
+    const beforeSeqRaw = url.searchParams.get('beforeSeq')
+    if (beforeSeqRaw !== null && beforeSeqRaw !== '') return null
     const afterSeqRaw = url.searchParams.get('afterSeq')
     if (afterSeqRaw !== null && afterSeqRaw !== '' && /^\d+$/.test(afterSeqRaw)) {
       const after = Number(afterSeqRaw)
@@ -186,7 +229,9 @@ function tunnelSignature(c) {
 }
 /** 「这份配置里哪几项决定局域网代理要重建」。 */
 function lanSignature(c) {
-  return JSON.stringify([Boolean(c.enabled), Boolean(c.lanEnabled), c.lanPort || 0, c.upstreamPort || 0, c.instanceId || '', c.pairingCode || '', c.lanSecret || ''])
+  // **配对码与票据不在其中**：它们由 `currentPairing` 现读，改它们不该重建监听 ——
+  // 配对成功就要换一次（§5.1），跟着重建会把刚握上的连接掐掉。
+  return JSON.stringify([Boolean(c.enabled), Boolean(c.lanEnabled), c.lanPort || 0, c.upstreamPort || 0, c.instanceId || '', c.lanSecret || ''])
 }
 /** 「这份配置里哪几项决定网络监视器要不要重排」。 */
 function monitorSignature(c) {
@@ -237,7 +282,7 @@ function startTunnel() {
   stopTunnel(); tunnelState = 'connecting'
   publishState()
   const current = new RelayTunnel({
-    relayUrl: core.tunnelWsUrl(config.relayUrl), instanceId: config.instanceId, pairingCode: config.pairingCode,
+    relayUrl: core.tunnelWsUrl(config.relayUrl), instanceId: config.instanceId,
     name: config.name, upstream: upstream(),
     registerSecret: config.registerSecret,
     lanUrls: currentLanUrls(),
@@ -275,10 +320,22 @@ function startLan() {
   stopLan(); lanState = 'connecting'
   publishState()
   const current = createLanProxy({
-    lanPort: config.lanPort, pairingCode: config.pairingCode, instanceId: config.instanceId, lanSecret: config.lanSecret,
+    lanPort: config.lanPort, instanceId: config.instanceId, lanSecret: config.lanSecret,
+    // 配对码与票据走取值器：配对成功之后宿主会换掉它们（§5.1），而重建局域网代理会把
+    // 刚握上的连接全掐掉 —— 换值不该动监听。
+    currentPairing: () => ({ code: config.pairingCode, ticket: config.pairingTicket || '' }),
     upstreamPort: config.upstreamPort,
     readSnapshot: snapshotRead,
     onLog: (...args) => process.stderr.write(`[dsh-ai-hub sidecar] ${args.join(' ')}\n`),
+    // 配对成功之后换码 + 换票据：走宿主的控制面（那是唯一能写状态文件的地方）。
+    onPaired: () => {
+      void parentJson('/api/relay/internal/rotate-pairing', {}).catch(() => undefined)
+    },
+    // 签发交给主进程（唯一写方）：旁路自己写盘会和主进程那份互相覆盖。
+    issueCredential: async (device, extra) => {
+      const result = await parentJson('/api/relay/internal/issue-credential', { device: device || {}, extra: extra || {} })
+      return result.data || result
+    },
     onApprove: async (device) => {
       try {
         const result = await parentJson('/api/relay/internal/approval', { device: device || {} })
@@ -306,10 +363,11 @@ function startLan() {
 }
 async function configure(next) {
   if (!next || typeof next !== 'object' || Array.isArray(next)) throw new Error('invalid configuration')
-  const allowed = ['enabled', 'relayUrl', 'instanceId', 'pairingCode', 'name', 'upstreamPort', 'lanPort', 'lanEnabled', 'lanSecret', 'registerSecret']
+  const allowed = ['enabled', 'relayUrl', 'instanceId', 'pairingCode', 'pairingTicket', 'name', 'upstreamPort', 'lanPort', 'lanEnabled', 'lanSecret', 'registerSecret']
   if (Object.keys(next).some(key => !allowed.includes(key))) throw new Error('unknown configuration field')
   if (typeof next.instanceId !== 'string' || next.instanceId.length > 128) throw new Error('invalid instanceId')
   if (typeof next.pairingCode !== 'string' || !/^\d{6}$/.test(next.pairingCode)) throw new Error('invalid pairingCode')
+  if (next.pairingTicket !== undefined && (typeof next.pairingTicket !== 'string' || !/^[A-Za-z0-9_-]{0,64}$/.test(next.pairingTicket))) throw new Error('invalid pairingTicket')
   if (typeof next.upstreamPort !== 'number' || !Number.isInteger(next.upstreamPort) || next.upstreamPort < 1 || next.upstreamPort > 65535) throw new Error('invalid upstreamPort')
   if (next.lanPort !== undefined && (!Number.isInteger(next.lanPort) || next.lanPort < 1024 || next.lanPort > 65535)) throw new Error('invalid lanPort')
   if (next.registerSecret !== undefined && (typeof next.registerSecret !== 'string' || next.registerSecret.length > 512)) throw new Error('invalid registerSecret')
@@ -333,7 +391,8 @@ async function configure(next) {
   }
   if (!tunnelNeedsRebuild && tunnel) {
     const patch = {}
-    if (previous.pairingCode !== config.pairingCode) patch.pairingCode = config.pairingCode
+    // **配对码不再进注册帧**（§5.2）：中转从来没读过它（`ws.rs` 原文「不保存也不校验」），
+    // 而带上它就等于把「谁能配这台机器」的一半凭证交给链路上的第三方。
     if (previous.name !== config.name) patch.name = config.name
     if (lanNeedsRebuild) patch.lanUrls = currentLanUrls()
     if (Object.keys(patch).length) tunnel.updateRegistration(patch)
@@ -365,7 +424,12 @@ const server = http.createServer(async (req, res) => {
       // 桌面→relay 主动推送（移动端镜像缓存）：复用隧道立即 sendJson；同时在本地保留快照供读取隔离。
       if (body && typeof body === 'object' && body.kind === 'sync') localSnapshot = body;
       if (tunnel && tunnel.connected) {
-        tunnel.sendJson(T.sync, 0, body && typeof body === 'object' ? body : { kind: 'raw', data: body });
+        // kind === 'push' 是 iOS 推送帧（pushRegister / pushSend），帧类型由 pushFrame
+        // 决定，不再一律塞进 sync——中转按帧类型分发，塞错类型等于发到黑洞。
+        const frameType = body && typeof body === 'object' && body.kind === 'push'
+          ? (body.pushFrame === 'register' ? T.pushRegister : T.pushSend)
+          : T.sync;
+        tunnel.sendJson(frameType, 0, frameForTunnel(body));
         return send(res, 202, { ok: true });
       }
       return send(res, 503, { ok: false, error: 'tunnel not connected' });

package/lib/update-install.cjs

@@ -43,7 +43,14 @@
  *
  * 装是**就地替换插件文件**，正在干活的对话可能读到半个包。市场那条路有一道这样的闸
  * （`AGENTS_RUNNING`），这里也补上了 —— 判到有人跑就**不动盘**，如实报成「可再试」。
- * `force`（面板上的「强制更新」）是用户明说「我知道，装吧」的那一挡，会跳过它。
+ *
+ * 两档能跳过它：`force`（面板上的「强制更新」，用户明说「我知道，装吧」）与 `auto`（宿主
+ * 每 10 分钟那一轮自动更新）。后者是有意的取舍：手机那边几乎一直有对话在跑，按着这道闸等，
+ * 自动更新实际上永远轮不到 —— 而它的定义就是「没人看着也会发生」。
+ *
+ * `auto` **只**跳过这道闸：照样要有新版才装（不跳过下面那条判断），也不一开始就带发布时长
+ * 开关（撞上再重试一次就够了）。把 `force` 那一档借给自动会在每 10 分钟把同一个版本重装
+ * 一遍，那不是自动更新。
  *
  * 顺序上**先答「有没有新版」**：没东西可装时拿一句「有对话在跑」挡在前面是误导，用户会以为
  * 是那个原因，而真正的答案是「已经是最新」。
@@ -459,13 +466,14 @@ async function installLatest({
  * 把它搬到插件自己这条路上来。判到有人跑就**不动盘**，如实报成「可再试」，下个 tick 再来。
  *
  * `force` 是**用户明说「我知道，装吧」**的那一挡（面板上那颗「强制更新」）：它同时跳过
- * 这道闸和「新发布先晾一会儿」的门槛。自动更新永远不带 force。
+ * 这道闸和「新发布先晾一会儿」的门槛，而且不管有没有新版都装一遍。`auto`（宿主那一轮自动
+ * 更新）只跳过这道闸，其余照旧 —— 见文件头。
  */
 async function installLatestIfNeeded(options = {}) {
-  const { profileNodeModules, force = false, name = DEFAULT_NAME, agents = null } = options;
+  const { profileNodeModules, force = false, auto = false, name = DEFAULT_NAME, agents = null } = options;
   const beforeVersion = installedVersion(profileNodeModules, name);
   // 来源那道门排在最前：非注册表来源连「线上最新是几」都不用问 —— 答案再新也不该装，
-  // 而且这一条同时管着手动与自动两条路（自动更新永远不带 force，照样过不去）。
+  // 而且这一条同时管着手动与自动两条路（`force` / `auto` 都过不去）。
   const source = declaredSource(path.dirname(profileNodeModules), name);
   const gate = installAllowedFor(source);
   if (!gate.ok) {
@@ -497,7 +505,7 @@ async function installLatestIfNeeded(options = {}) {
       check,
     };
   }
-  if (!force) {
+  if (!force && !auto) {
     const running = runningAgentIds(agents);
     if (running.length > 0) {
       return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.1.100",
+  "version": "0.2.1",
   "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",
@@ -42,7 +42,8 @@
   },
   "scripts": {
     "start": "node host.js",
-    "test": "node --test test/*.test.cjs && node test/lan-direct-e2e.cjs && node test/sidecar-facade.cjs"
+    "test": "node --test test/*.test.cjs && node test/lan-direct-e2e.cjs && node test/sidecar-facade.cjs",
+    "release:check": "node scripts/preflight-release.mjs"
   },
   "dependencies": {
     "@deepseek-ai/dsh-tool-ask-user": "0.2.1-rc.2",