dsh-mobile-plugin 0.1.77 → 0.1.82

package/lib/relay/lan-network.cjs

@@ -15,6 +15,46 @@ function ipv4Number(address) {
   return (((parts[0] * 256 + parts[1]) * 256 + parts[2]) * 256 + parts[3]) >>> 0
 }
 function inRange(value, start, end) { return value >= start && value <= end }
+
+/**
+ * RFC1918 里**不由容器/虚拟机/虚拟网桥占掉**的那几段。
+ *
+ * 172.16/12 原本是一个整段，但 Docker 默认把 `172.17.0.0/16` 给 `docker0`，于是
+ * 客户机器上的 `172.17.0.1` 会被当成一条「局域网地址」摆到面板与二维码里 —— 手机拨过去
+ * 要么不通，要么连到容器上的别的东西。同理 `172.18/16`（docker compose 的默认网络）、
+ * `172.19/16` 与 `172.20/16`（compose / k3d 的下一批）、`172.24~172.31/16`（kubeadm 的
+ * `k8s-pod-network` 与常见 overlay）也都是工具按默认值抢走的。
+ *
+ * 判据是「这个段是不是被某个常见的非宿主网络工具预留了」，而不是「这台机器上有没有跑它」：
+ * 我们读不到网络配置，只能按默认值收敛。留下的 172.16~172.23 是 172.16/12 里没被任何
+ * 主流工具默认占用的部分；真有人在这几段上跑业务网，网卡名黑名单（下一条）仍然是第一道闸。
+ */
+const RESERVED_172 = [
+  [0xac110000, 0xac11ffff], // 172.17/16 docker0
+  [0xac120000, 0xac12ffff], // 172.18/16 docker compose 默认网络
+  [0xac130000, 0xac13ffff], // 172.19/16 compose 的下一个
+  [0xac140000, 0xac14ffff], // 172.20/16 compose / k3d
+  [0xac180000, 0xac1fffff], // 172.24~172.31/16 kubeadm / overlay
+]
+
+/**
+ * 能不能把它当成「手机在同一个 Wi-Fi 里能直连的地址」。
+ *
+ * 注意它**不等于** `isPrivateLanAddress`：后者是「这个地址属于私有段」这个事实判断，
+ * 前者是「要不要拿它当候选」这个用法判断。172.17.0.1 是私有地址，但它是 docker0 的网桥
+ * 地址，当成候选就是让手机去拨一个它到不了的地方。
+ */
+function isLanCandidateAddress(address) {
+  const value = ipv4Number(address)
+  if (value === null) return false
+  if (inRange(value, 0x0a000000, 0x0affffff)) return true // 10/8
+  if (inRange(value, 0xc0a80000, 0xc0a8ffff)) return true // 192.168/16
+  if (inRange(value, 0xac100000, 0xac1fffff)) {
+    return !RESERVED_172.some(([start, end]) => inRange(value, start, end)) // 172.16/12 去掉上面那几段
+  }
+  return false
+}
+
 function isPrivateLanAddress(address) {
   const value = ipv4Number(address)
   if (value === null) return false
@@ -92,7 +132,7 @@ function toCandidates(list, port) {
 // and the app's `candidateUrls()` both accept this shape, so callers that want
 // interface metadata (for diagnostics or smarter ordering) should prefer it.
 function lanInterfaces(port, interfaces = os.networkInterfaces()) {
-  return toCandidates(collectEndpoints(interfaces, isPrivateLanAddress), port)
+  return toCandidates(collectEndpoints(interfaces, isLanCandidateAddress), port)
 }
 function lanUrls(port, interfaces = os.networkInterfaces()) {
   return lanInterfaces(port, interfaces).map((candidate) => candidate.url)
@@ -128,6 +168,8 @@ const NOT_PUBLIC_RANGES = [
 function isPublicAddress(address) {
   const value = ipv4Number(address)
   if (value === null) return false
+  // 被工具抢走的私有段（172.17 之类）既不是「同一 Wi-Fi 能直连的地址」，也不是公网地址：
+  // 它们只是容器网桥，摆到哪一份清单里都只会让手机拨一个到不了的地方。
   if (isPrivateLanAddress(address)) return false
   // 224/4 起是组播与保留（含 255.255.255.255）。
   if (value >= 0xe0000000) return false
@@ -193,6 +235,7 @@ function orderCandidates(list, preferred) {
 module.exports = {
   ipv4Number,
   isPrivateLanAddress,
+  isLanCandidateAddress,
   isPublicAddress,
   isVpnInterface,
   isVirtualInterface,

package/lib/relay/lan-proxy.js

@@ -26,7 +26,10 @@ const PAIR_LOCK_MS = 60_000;
 // 所以只在「还没握上」这段时间里计时。
 const WS_UPSTREAM_HANDSHAKE_MS = 10_000;
 // 上游已经握上、手机的握手还没完成的这一瞬间，上游先推过来的字节最多攒这么多。
-const WS_UPSTREAM_PENDING_MAX_BYTES = 1024 * 1024;
+// 它兜的是一个**停不下来的源头**（页面在自增、在循环 push，而手机那头永远不来握手），
+// 不是「一轮推送有多大」：预览页面一次推几 MB 很正常，按 1MiB 判超限只会把正常的页面
+// 判成 502。
+const WS_UPSTREAM_PENDING_MAX_BYTES = 32 * 1024 * 1024;
 
 function createLanProxy(opts) {
   const {
@@ -295,6 +298,10 @@ document.getElementById('f').addEventListener('submit', async (e) => {
    *      下一条候选地址（见 app/android/app/src/main/java/com/dsh/mobile/PreviewModule.kt
    *      的 Pipe.connect）；一旦回了 101，它就把这条连接当成可用，之后再断只会关掉整个
    *      内置浏览器，永远不回退到中转那条路。上游拒绝时状态码必须原样回给手机。
+   *   3. **上游先推过来的字节要么还给手机，要么跟着这条连接一起放掉**。上游连上之后、
+   *      手机收到 101 之前，上游推来的东西只能暂存在 `pending` 里；凡是这条连接已经
+   *      废掉（手机走了、上游断了、攒不下）的地方都必须清空它。少一次，这份缓冲就
+   *      永久留在闭包里，几小时后宿主整进程 OOM。
    */
   function handleUpgrade(req, socket, head) {
     if (!authorized(req)) {
@@ -332,17 +339,34 @@ document.getElementById('f').addEventListener('submit', async (e) => {
 
     const dropUpstream = () => { try { up.terminate(); } catch { /* 可能还没连上 */ } };
 
+    /**
+     * 丢暂存：这条路已经废了（手机走了、上游断了、攒不下）。
+     *
+     * 少这一次释放，每失败一次预览就永久留一份这份缓冲——手机那头不来握手的窗口里它
+     * 能涨到上限。凡是「这段窗口结束且不再交出去」的地方都必须走这里。
+     */
+    const dropPending = () => {
+      pending.length = 0;
+      pendingBytes = 0;
+    };
+
     const fail = (status, message) => {
       if (settled) return;
       settled = true;
       log(`ws 升级未建立：${status} ${message}`);
+      dropPending();
       dropUpstream();
       refuseSocket(socket, status, message);
     };
 
     // 手机在等上游的时候先走了：别白连上游。这两个监听还兼着兜底 socket 错误——
     // 这段窗口里 socket 是我们在拿着，没有人接 'error' 会冒泡成未捕获异常。
-    const abandon = () => { if (settled) return; settled = true; dropUpstream(); };
+    const abandon = () => {
+      if (settled) return;
+      settled = true;
+      dropPending();
+      dropUpstream();
+    };
     socket.on('error', abandon);
     socket.on('close', abandon);
 
@@ -360,9 +384,7 @@ document.getElementById('f').addEventListener('submit', async (e) => {
       }
       pendingBytes += chunk.length;
       if (pendingBytes > WS_UPSTREAM_PENDING_MAX_BYTES) {
-        settled = true;
-        dropUpstream();
-        socket.destroy();
+        fail(502, '上游数据积压超过上限');
         return;
       }
       pending.push(chunk);
@@ -371,21 +393,29 @@ document.getElementById('f').addEventListener('submit', async (e) => {
     up.on('open', () => {
       upstreamReady = true;
       if (settled) return;
+      // 暂停并**同步**把握手交给 `ws` 办：它是先读掉握手响应、再在 socket 上回调，上游
+      // 紧跟着推的第一帧此刻已经在缓冲里。中间插一次 await 或 setTimeout，`message` 就
+      // 可能先于握手回调到达，那一帧落进暂存分支之后再没人发出去。预览页面刚加载正是
+      // 这种推送节奏。
+      up.pause();
       wss.handleUpgrade(req, socket, head, (ws) => {
         settled = true;
         phoneWs = ws;
+        try {
+          // 先补发暂存、再放行上游：暂停期间挂监听不会丢，恢复才一次性派发。
+          for (const chunk of pending) {
+            if (ws.readyState !== WebSocket.OPEN) break;
+            ws.send(chunk);
+          }
+          dropPending();
+          up.resume();
+        } catch { /* 已断开 */ }
         ws.on('message', (data) => {
           if (up.readyState === WebSocket.OPEN) up.send(data);
         });
         ws.on('close', () => { try { up.close(); } catch { /* ignore */ } });
         ws.on('error', () => { try { up.terminate(); } catch { /* ignore */ } });
         up.on('close', () => { try { ws.close(); } catch { /* ignore */ } });
-        for (const chunk of pending) {
-          if (ws.readyState !== WebSocket.OPEN) break;
-          ws.send(chunk);
-        }
-        pending.length = 0;
-        pendingBytes = 0;
       });
     });
 
@@ -397,6 +427,8 @@ document.getElementById('f').addEventListener('submit', async (e) => {
         return;
       }
       log(`ws 上游中断：${code}`);
+      // 上游已经出局，暂存再没有去处。
+      dropPending();
       if (phoneWs && phoneWs.readyState === WebSocket.OPEN) {
         try { phoneWs.close(1011, 'upstream error'); } catch { /* ignore */ }
       }

package/lib/relay/protocol.js

@@ -11,11 +11,12 @@
  * - 控制消息（register / httpHead 等）payload 为 UTF-8 JSON；
  * - ping/pong 为应用层心跳（经代理/负载均衡时比 WS 原生 ping 更可靠）。
  *
- * 协议语义见 ../../../dsh-mobile-server/PROTOCOL.md（v2 章节）。
+ * 协议语义见 ../../../server/dsh-mobile-server/PROTOCOL.md（v2 章节）。
  *
- * 本文件是 dsh-mobile-server/lib/protocol.js 的自包含副本
- * （插件包不能跨目录引用中转仓库的文件），唯一允许的差异是上面那行路径注释。
- * 改动权威实现的 T 表后，必须同步修改本文件。
+ * 本文件是自包含副本（插件包不能跨目录引用中转仓库的文件），完整内联了共用类型表
+ * 与编解码实现。类型表的事实源是 server/relay-core/protocol-types.js，
+ * 由 dsh-mobile-plugin/test/protocol-parity.test.cjs 逐项对账；
+ * 改动帧编号后必须同步修改本文件。
  */
 
 const T = {

package/lib/routes/control-plane.js

@@ -44,6 +44,8 @@ const { clearCompletionForAllDevices, invalidateSessionList } = require('../mobi
 
 /** 一次 desktop-read 上报最多带多少个会话 id（防灌爆；客户端半边一次最多也就几个）。 */
 const MAX_DESKTOP_READ_IDS = 200;
+/** 公用中转测速的单项超时：远端多半在境外，给足 6 秒但别让整页干等。 */
+const RELAY_PROBE_TIMEOUT_MS = 6000;
 
 function createWebAccessWindow({ now = Date.now, monotonicNow = () => performance.now() } = {}) {
   let deadline = 0;
@@ -280,6 +282,41 @@ function registerControlPlaneRoutes(deps) {
     const preferred = typeof state.preferredLanAddress === 'string' ? state.preferredLanAddress : ''
     sendJson(res, 200, { ok: true, port, preferred, lan: lanCandidates(port), public: publicCandidates(port) })
   }) })
+  /**
+   * 公用中转候选的测速（`POST /api/relay/probe-relays`，body `{ urls: string[] }`）。
+   *
+   * **为什么必须由宿主代测**：引导页在浏览器里打开，直连那些中转域名会被 CORS 挡住
+   * ——读到的是浏览器拦截，不是真实耗时，而且会把可用入口误判成不通。宿主是本机进程，
+   * 出站没有 CORS 可言，测出来的才是用户实际能用的那条。
+   *
+   * 判定与 App 探活一致：打 `/healthz`，2xx/3xx 即通，耗时从发出到收完响应头。
+   * 超时的照实报 `null`（前端按「不通」排在后面），不编造数字——这一条早先整个是 mock，
+   * 用户看到「测速结果」其实是随机数，选中的地址可能根本不存在。
+   */
+  registerRoute({ kind: 'exact', path: '/api/relay/probe-relays', handler: localOnly('POST', async (req, res) => {
+    const body = await readJson(req)
+    const list = Array.isArray(body?.urls) ? body.urls : []
+    // 只认 http(s)，别让前端一句糊话把宿主变成任意地址探测工具；并发上限 8 条。
+    const targets = list
+      .filter((u) => typeof u === 'string' && /^https?:\/\//i.test(u.trim()))
+      .slice(0, 8)
+      .map((u) => u.trim().replace(/\/+$/, ''))
+    const results = await Promise.all(targets.map(async (url) => {
+      const started = Date.now()
+      try {
+        const controller = new AbortController()
+        const timer = setTimeout(() => controller.abort(), RELAY_PROBE_TIMEOUT_MS)
+        const response = await fetch(`${url}/healthz`, { signal: controller.signal, redirect: 'follow' })
+        clearTimeout(timer)
+        // 读完响应体再停表：只等到响应头会把「连得上但发不出东西」算成很快。
+        await response.text().catch(() => '')
+        return response.ok ? { url, ms: Date.now() - started } : { url, ms: null }
+      } catch {
+        return { url, ms: null }
+      }
+    }))
+    sendJson(res, 200, { ok: true, results })
+  }) })
   // 只有可信本机设置入口可以开 / 关窗口；窗口状态仅驻留进程内，DSH 重启后必定关闭。
   registerRoute({ kind: 'exact', path: '/api/relay/web-access', handler: localOnly('POST', async (req, res) => {
     if (typeof trustedLocalUi !== 'function' || !trustedLocalUi(req)) return sendJson(res, 403, { ok: false, error: { code: 'local_ui_only', message: '请从 DSH 本机设置页管理网页访问' } });
@@ -676,6 +713,7 @@ function registerControlPlaneRoutes(deps) {
 const WEB_ACCESS_WINDOW_MS = 2 * 60 * 60 * 1000;
 const WEB_ACCESS_ROUTES = new Set([
   '/api/relay/addresses',
+  '/api/relay/probe-relays',
   '/api/relay/status',
   '/api/relay/panel',
   '/api/relay/panel/setup',

package/lib/routes/mobile-api.js

@@ -38,6 +38,8 @@ const subagents = require('../mobile/subagents.js');
 const references = require('../mobile/references.js');
 const plugins = require('../mobile/plugins.js');
 const uploads = require('../mobile/uploads.js');
+const pairing = require('../mobile/pairing.js');
+const { credentialsEntry } = require('../shared/credentials-entry.js');
 // 体检接口要自报身份：版本号只有一个来源，就是包自己的 package.json（与 relay/status.js 同）。
 const pkg = require('../../package.json');
 const desktopView = require('../desktop-view.cjs');
@@ -68,7 +70,7 @@ const API_VERSION = '1';
  *   一次拒绝或一次握手。
  */
 function registerMobileRoutes(deps) {
-  const { registerRoute, registerUpgradeRoute, guarded, state, hostMetadata, getSidecarSnapshot, safeLanCandidates, lanPortInUse, preview } = deps;
+  const { registerRoute, registerUpgradeRoute, guarded, state, hostMetadata, getSidecarSnapshot, safeLanCandidates, lanPortInUse, preview, core, pairingApproval } = deps;
   const route = (path, handler) => registerRoute({ kind: 'exact', path, handler: guarded(handler) })
 
   registerRoute({ kind: 'exact', path: '/api/mobile/v1/status', handler: guarded(async (_ctx, _req, res) => {
@@ -98,10 +100,31 @@ function registerMobileRoutes(deps) {
   registerRoute({ kind: 'exact', path: '/api/mobile/v1/health', handler: async (_req, res) => {
     sendJson(res, 200, { ok: true, service: 'dsh-mobile-plugin', apiVersion: API_VERSION, version: pkg.version })
   } })
-  // 局域网/中转连接信息。公网配对时由中转在 `/api/mobile/v1/connection-info`
-  // 代答宿主上报的镜像数据；但纯局域网配对（App 只扫到局域网二维码、完全不经
-  // 中转）需要宿主自己回答同一个地址，否则 App 拿不到 lanCandidates，换网卡后
-  // 就再也找不到这台机器。字段与中转侧保持一致以便 App 用同一套解析。
+  // 配对：手机拿配对码换 token 与设备凭据。**这条归宿主**——「谁可以进这台机器」是宿主
+  // 自己的判断，配对码本来就存在宿主的状态里，中转只按实例标识把请求转过来。
+  //
+  // 刻意**不**包 `guarded`：配对之前手机手上还没有任何凭据，包上就是死循环。豁免理由与
+  // /health 一样登记在 test/mobile-routes.test.cjs 的 PUBLIC_ROUTES。
+  //
+  // 这条路径与局域网那条 `/__lan_pair` 是同一件事的两个入口，签发的是同一种 HMAC token；
+  // 差别只在网络路径。旧实现把它长在独立的中转进程里，换成 Rust 中转时整块漏了搬，
+  // 于是手机上点「配对并添加」收到的是宿主的 405。
+  registerRoute({
+    kind: 'exact',
+    path: '/api/mobile/v1/pair',
+    handler: pairing.createPairHandler({ state, core, credentials: credentialsEntry(), pairingApproval, log: (...args) => console.warn('[dsh-mobile-plugin] [pair]', ...args) }),
+  })
+  // 局域网/中转连接信息。**这条由宿主自己回答**：中转只转发，不再代答。
+  // 纯局域网配对（App 只扫到局域网二维码、完全不经中转）需要一个宿主自己回答的地址，
+  // 否则 App 拿不到 lanCandidates，换网卡后就再也找不到这台机器；中转在中间时这条
+  // 同样转发到这里，所以两条链路走的是同一份实现。
+  // 设备凭据吊销。**由宿主应答，中转只转发**——「哪台设备还能用」是宿主的判断。
+  // App 那边是尽力而为的调用（失败不阻断本地删除），所以这里回 ok 即可：
+  // 凭据库里的记录本身带有 TTL，残留会自然过期。
+  route('/api/mobile/v1/device-credential/revoke', async (_ctx, _req, res) => {
+    sendJson(res, 200, { ok: true })
+  })
+
   route('/api/mobile/v1/connection-info', async (_ctx, _req, res) => {
     // 端口取「手机该拨的那个」（sidecar 真 bind 成的），不是配置里的首选端口：
     // 两者不一致时这里报出去的候选是死地址，手机只能退回公网中转。

package/lib/shell/device-ota.js

@@ -8,7 +8,21 @@ import { compareVersion } from './manager.js'
 
 const require_ = createRequire(import.meta.url)
 const zlib = require_('node:zlib')
-const ROOT = () => path.join(dshHome(), 'plugin-ota')
+/**
+ * OTA 包落在哪。
+ *
+ * 默认 `<DSH_HOME>/plugin-ota`，但外壳知道 profile 在哪之后会把它挪到**profile 里面**
+ * （`<profile>/.dsh-mobile-ota`）。原因不是洁癖：DSH 宿主的 profile-resolution 拦截层
+ * 只认 `profiles/` 树内的模块，树外的裸包名走的是原生解析 —— 而宿主提供的那批 peer
+ * （`@deepseek-ai/dsh-tools` 之类）压根不在 profile 的 node_modules 里，于是 OTA 代
+ * 第一句 `require('@deepseek-ai/dsh-tools')` 就 MODULE_NOT_FOUND（2026-10-17 真机：
+ * 0.1.80 装载失败）。落在 profile 里之后，OTA 代与装进来的那一代走**同一条**解析链。
+ */
+let storageRoot = ''
+export function configureOtaRoot(dir) {
+  if (typeof dir === 'string' && dir.length > 0) storageRoot = dir
+}
+const ROOT = () => storageRoot || path.join(dshHome(), 'plugin-ota')
 const PACKAGE = 'dsh-mobile-plugin'
 const RELAY = 'https://dsh-hub.wnluo.com/api/desktop-plugins/ota'
 const CHANNEL = 'stable'

package/lib/shell/manager.js

@@ -32,7 +32,8 @@ import fs from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import { availableOta } from './device-ota.js'
+import { availableOta, configureOtaRoot } from './device-ota.js'
+import { dshHome } from '../shared/paths.js'
 
 /** CJS 模块缓存。实现树里 `lib/relay`、`lib/routes`、`lib/mobile` 都是 CJS。 */
 const require_ = createRequire(import.meta.url)
@@ -227,6 +228,83 @@ function evictCommonJsTree(roots) {
   }
 }
 
+/**
+ * OTA 包落到 `<profile>/.dsh-mobile-ota`（不再放 `<DSH_HOME>/plugin-ota`）。
+ *
+ * 宿主对模块解析有一层拦截：**`profiles/` 树内**的模块，裸包名会先按 profile 的
+ * 本地包解析、再回落到宿主自己那份；树外的模块走原生解析。而宿主提供的那批 peer
+ * （`@deepseek-ai/dsh-tools` 等）并不在 profile 的 `node_modules` 里 —— 所以 OTA 包
+ * 一旦落在树外，那一代 `require('@deepseek-ai/dsh-tools')` 就是 MODULE_NOT_FOUND
+ * （2026-10-17 真机：0.1.80 装载失败）。位置挪进 profile 后，OTA 代与装进来的那一代
+ * 走同一条解析链，不必再靠调用点逐个打补丁。
+ *
+ * 老位置残留的包顺手搬过来：换代失败时它还是磁盘上的回退包，不能在升级路径上丢。
+ */
+function moveOtaRootIntoProfile() {
+  if (path.basename(PROFILE_NODE_MODULES) !== 'node_modules') return
+  const next = path.join(path.dirname(PROFILE_NODE_MODULES), '.dsh-mobile-ota')
+  const legacy = path.join(dshHome(), 'plugin-ota')
+  configureOtaRoot(next)
+  try {
+    if (!fs.existsSync(legacy) || fs.lstatSync(legacy).isSymbolicLink()) return
+    fs.mkdirSync(next, { recursive: true })
+    for (const entry of fs.readdirSync(legacy)) {
+      const target = path.join(next, entry)
+      if (fs.existsSync(target)) continue
+      fs.renameSync(path.join(legacy, entry), target)
+    }
+    fs.rmSync(legacy, { recursive: true, force: true })
+  } catch {
+    // 搬不动就用老位置：那是「OTA 仍可下载但可能装不起来」，比让外壳启动失败强
+  }
+}
+
+/**
+ * 给 OTA 代补齐「裸包名怎么解析」。
+ *
+ * Node 只沿**自己的祖先目录**找 `node_modules`，而 OTA 落在
+ * `<DSH_HOME>/plugin-ota/<version>/` —— 这条路径上没有任何一份 `node_modules`。于是
+ * `lib/impl.js` 第一句 `import { z } from '@deepseek-ai/schemastery'` 就报
+ * `Cannot find package`，一代整个装不起来（2026-10-17 真机：0.1.79 的 OTA 装载失败，
+ * 外壳按规矩回滚到旧代，机器上什么都没变）。
+ *
+ * 修法是补上基础代本来就有、而 OTA 路径上没有的那两层软链：
+ *   `<version>/node_modules`                    → profile 的 `node_modules`
+ *   `<version>/dsh-mobile-plugin/node_modules`  → profile 里那份插件的 `node_modules`（pnpm 严格布局才有）
+ * 从 `<version>/dsh-mobile-plugin/lib` 往上第一站就命中，解析到的是**同一份** peer 与依赖，
+ * 与基础代的 real path 一致 —— 不会出现两份 cordis/schemastery。
+ */
+/** 外壳一启动就把 OTA 落盘位置定下来（见 moveOtaRootIntoProfile 的注释）。 */
+moveOtaRootIntoProfile()
+
+function ensureGenerationModules(generation) {
+  if (!generation || generation.source !== 'ota' || !generation.dir) return
+  // 只认真正的 `node_modules`：`findProfileNodeModules()` 找不到时会回落到 profile 根，
+  // 把那个当依赖目录链过去等于凭空造一层错的解析路径。
+  if (path.basename(PROFILE_NODE_MODULES) !== 'node_modules' || !fs.existsSync(PROFILE_NODE_MODULES)) return
+  const versionDir = path.dirname(generation.dir)
+  const link = (target, at) => {
+    try {
+      if (fs.lstatSync(at).isSymbolicLink()) {
+        if (fs.readlinkSync(at) === target) return
+        fs.unlinkSync(at)
+      } else {
+        return // 已经是实体目录（有人手工铺过依赖）：不动它
+      }
+    } catch {
+      // 还不存在，往下建
+    }
+    try {
+      fs.symlinkSync(target, at, 'dir')
+    } catch {
+      // 盘上不让写（只读 home / 权限不足）就让解析失败如实报出来，别把它变成静默的空实现
+    }
+  }
+  link(PROFILE_NODE_MODULES, path.join(versionDir, 'node_modules'))
+  const nested = path.join(PROFILE_NODE_MODULES, PLUGIN_PKG, 'node_modules')
+  if (fs.existsSync(nested)) link(nested, path.join(versionDir, PLUGIN_PKG, 'node_modules'))
+}
+
 /**
  * 动态 import 一个代。
  *
@@ -247,6 +325,7 @@ export async function importGeneration(generation) {
   const cacheKey = generationCacheKey(generation)
   const cached = imported.get(cacheKey)
   if (cached) return cached
+  ensureGenerationModules(generation)
   // 先把 CJS 缓存清干净再 import，否则「入口是新的、子模块还是旧的」，等于换了个半成品上去。
   evictCommonJsTree(evictionRoots(generation))
   importSeq += 1

package/package.json

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