dsh-mobile-plugin 0.5.22 → 0.5.23

package/lib/mobile/live-steps.js

@@ -48,6 +48,8 @@ function turnOf(ctx, sessionId) {
       /** 还没发出去的那几步（`drainLiveSteps` 取走）。 */
       pending: [],
       ended: false,
+      /** 这份副本属于哪一轮（宿主 turn 号）：换轮就整份作废，见 `turnForEvent`。 */
+      turnNo: null,
     };
     bucket.delete(sessionId);
     bucket.set(sessionId, turn);
@@ -57,6 +59,28 @@ function turnOf(ctx, sessionId) {
   return turn;
 }
 
+/**
+ * 把一条事件归到它所属的那一轮；**轮号一变就整份作废**。
+ *
+ * 为什么要靠事件自带的 `data.turn` 兜这一手：`noteLiveEvent` 只在这条流上收到 `turn/start`
+ * 时清桶，可断线重连后那一轮的 `turn/start` 已经在重连之前发生过、被当作「回放已覆盖」丢掉，
+ * 于是新的一轮的步骤会接着上一轮往后长，越积越多、最后全挂在最新那条消息下。每一帧增量
+ * 都带着它属于哪个 turn，用它来判就不会漏：turn 号变了就把整轮副本换掉（下一轮的步骤从空起）。
+ * 同一轮内（turn 号相同）原样沿用。
+ */
+function turnForEvent(ctx, sessionId, data) {
+  const bucket = bucketOf(ctx);
+  const explicitTurn = data && typeof data.turn === 'number' ? data.turn : null;
+  let turn = bucket.get(sessionId);
+  if (turn && explicitTurn !== null && turn.turnNo !== null && turn.turnNo !== explicitTurn) {
+    bucket.delete(sessionId);
+    turn = undefined;
+  }
+  if (!turn) turn = turnOf(ctx, sessionId);
+  if (turn.turnNo === null && explicitTurn !== null) turn.turnNo = explicitTurn;
+  return turn;
+}
+
 /** 把一段文本接到已有的那段后面，超过上限就只留尾巴。 */
 function appendText(prev, next) {
   if (typeof next !== 'string' || next === '') return prev || '';
@@ -160,11 +184,12 @@ function noteLiveEvent(ctx, sessionId, event) {
   if (event.type === 'turn/start') {
     // 新的一轮开始：上一轮的过程副本作废（换掉了，就别再让人点开旧内容）。
     bucketOf(ctx).delete(sessionId);
-    turnOf(ctx, sessionId);
+    const started = turnOf(ctx, sessionId);
+    if (data && typeof data.turn === 'number') started.turnNo = data.turn;
     return;
   }
   if (!data) return;
-  const turn = turnOf(ctx, sessionId);
+  const turn = turnForEvent(ctx, sessionId, data);
   if (event.type === 'assistant/message') {
     // 一步落定：这一步的思考按块序号收尾（后面那一步的块序号从 0 重新数）。
     closeThoughtsOfStep(turn);
@@ -303,6 +328,13 @@ function liveStepsOf(ctx, sessionId) {
   return turn.steps.map((entry) => ({ key: entry.key, step: { ...entry.step } }));
 }
 
+/** 这份直播清单属于哪一轮（宿主 turn 号）——随 `session/live-steps` 帧下发，App 据此按轮隔离。 */
+function liveStepsTurnOf(ctx, sessionId) {
+  if (!ctx || typeof sessionId !== 'string' || !sessionId) return null;
+  const turn = liveStepTurnOf(ctx).get(sessionId);
+  return turn && typeof turn.turnNo === 'number' ? turn.turnNo : null;
+}
+
 /**
  * 取走「还没告诉过手机」的那几步。
  *
@@ -354,4 +386,4 @@ function clearLiveSteps(ctx, sessionId) {
   liveStepTurnOf(ctx).delete(sessionId);
 }
 
-module.exports = { noteLiveEvent, liveStepOf, liveStepsOf, drainLiveSteps, clearLiveSteps };
+module.exports = { noteLiveEvent, liveStepOf, liveStepsOf, liveStepsTurnOf, drainLiveSteps, clearLiveSteps };

package/lib/mobile/local-images.js

@@ -18,6 +18,8 @@
  * 保守取舍——宁可保留字面 markdown，也不给半截东西：
  * - 本机路径认三种：绝对（`/x/y.png`、`file:///x/y.png`）、`~/y.png`、相对（`deliverables/a.png`，
  *   按调用方给的工作区目录解析，与桌面端同口径；没给目录就当成不是本机图）；http(s)、`data:` 不碰；
+ * - 双分隔符打头的网页地址（协议相对 `//host/…`）与 Windows 网络 / 扩展路径（`\\host\…`、`\\?\…`）
+ *   不碰：它们不是本机文件，在 Windows 上会被当成 UNC 去 stat、一读就卡几十秒；
  * - 只认 png/jpg/jpeg/webp/gif，并核对魔术字节，不按扩展名撒谎；
  * - 宽高只读文件头（最多 64KB）；读不出来就不带宽高，App 那边照旧现量；
  * - 围栏代码块与行内代码里的图片语法不碰，那是写法示例。
@@ -85,7 +87,9 @@ function localImagePathOf(url, cwd) {
   let value = url.trim();
   if (!value) return null;
   if (value.startsWith('<') && value.endsWith('>')) value = value.slice(1, -1).trim();
-  if (/^[a-z][a-z0-9+.-]*:/i.test(value)) {
+  // 盘符路径（`C:\…`、`C:/…`）不是 URL 协议：单字母后跟分隔符的别当成 scheme 拦掉。
+  const hasUrlScheme = /^[a-z][a-z0-9+.-]*:/i.test(value) && !/^[a-z]:[\\/]/i.test(value);
+  if (hasUrlScheme) {
     if (value.slice(0, 7).toLowerCase() !== 'file://') return null;
     try {
       value = decodeURIComponent(value.slice(7));
@@ -96,6 +100,10 @@ function localImagePathOf(url, cwd) {
   } else if (value === '~' || value.startsWith('~/')) {
     value = path.join(os.homedir(), value.slice(1));
   }
+  // 双分隔符打头的是网页地址（协议相对 `//host/…`）或 Windows 网络 / 扩展路径（`\\host\…`、
+  // `\\?\…`）。它们不是本机文件，在 Windows 上会被当成 UNC 去 stat、一读就卡几十秒；
+  // `file://` 的远程主机经上面剥完也可能落到这里，同样不认。
+  if (/^[\\/]{2}/.test(value)) return null;
   if (!path.isAbsolute(value)) {
     if (!cwd) return null;
     value = path.resolve(cwd, value);
@@ -273,19 +281,154 @@ async function registerLocalImage(filePath) {
   const size = sane ? parsed : {};
   const entry = { filePath, mediaType, ...size, ...(over ? { tooLarge: true } : {}) };
   registry.set(id, entry);
-  while (registry.size > MAX_REGISTRY_ENTRIES) registry.delete(registry.keys().next().value);
+  trimRegistry();
   return { id, ...entry };
 }
 
+/** 登记表满了就淘汰最老的一条；取回来的临时文件一并删掉，别在地上留垃圾。 */
+function trimRegistry() {
+  while (registry.size > MAX_REGISTRY_ENTRIES) {
+    const oldestId = registry.keys().next().value;
+    const entry = registry.get(oldestId);
+    registry.delete(oldestId);
+    if (entry && entry.fetched && entry.filePath) fs.unlink(entry.filePath).catch(() => {});
+  }
+}
+
 /** 取图口用：只认登记表里的编号（构造不出来的编号一律 null → 404）。 */
 function localImageOf(id) {
   if (typeof id !== 'string' || !id) return null;
   return registry.get(id) || null;
 }
 
-/** 清空登记表（测试用）。 */
+/** 清空登记表（测试用）。取回来的临时文件一并删掉。 */
 function clearLocalImages() {
+  for (const entry of registry.values()) {
+    if (entry && entry.fetched && entry.filePath) fs.unlink(entry.filePath).catch(() => {});
+  }
   registry.clear();
+  loopbackUrlCache.clear();
+}
+
+/**
+ * 回环地址的主机名：出现在正文里时指的是「跑插件这台电脑自己」，手机拿着同一个地址
+ * 只会指回手机自己。生图插件常把成品图挂在自己电脑上的一个小服务上，回的就是这种地址。
+ */
+const LOOPBACK_HOSTNAMES = new Set(['127.0.0.1', 'localhost', '0.0.0.0', '::1', '::']);
+
+/** 取回回环图片的超时：只在投影一条消息时占这一小会儿，取不到就保持字面 markdown。 */
+const LOOPBACK_FETCH_TIMEOUT_MS = 4000;
+/** 失败后多久内不再重试同一地址：翻历史碰上已经关掉的服务，不该每次都干等一次超时。 */
+const LOOPBACK_FAIL_TTL_MS = 30 * 1000;
+/** 同一地址取到过的图片编号；翻历史时直接复用，不必重复取。 */
+const loopbackUrlCache = new Map();
+
+/**
+ * `![](…)` 里的地址若是**回环地址的 http(s) 图片**，回那条地址；否则 null。
+ *
+ * 只认回环：别的远程地址一律不碰 —— 那会把「本机图片」变成「替手机随便抓任意网址」，
+ * 能力面就从「读这台电脑上的文件」扩成了代理一切出站请求。回环地址连不到外网，
+ * 只是这台电脑自己起的服务，与「读本机文件」同一类。
+ */
+function loopbackImageUrlOf(url) {
+  if (typeof url !== 'string') return null;
+  let value = url.trim();
+  if (!value) return null;
+  if (value.startsWith('<') && value.endsWith('>')) value = value.slice(1, -1).trim();
+  if (!/^https?:\/\//i.test(value)) return null;
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return null;
+  }
+  const hostname = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, '');
+  return LOOPBACK_HOSTNAMES.has(hostname) ? value : null;
+}
+
+/**
+ * 取回的图片字节落成临时文件再登记：取图口按编号读 `filePath`，与磁盘上的图同一条路。
+ *
+ * 编号取内容哈希：同一张图反复出现只落一份。超过单张上限的照样登记、但标 `tooLarge`
+ * （取图口回 413，App 画「图片太大」占位），与磁盘图片那条口径一致。
+ */
+async function registerLocalImageBytes(buffer, mediaType) {
+  if (!buffer || buffer.length === 0) return null;
+  const id = crypto.createHash('sha1').update(buffer).digest('hex').slice(0, 16);
+  const known = registry.get(id);
+  if (known) return { id, ...known };
+  const over = buffer.length > MAX_IMAGE_BYTES;
+  const parsed = over ? null : imageSizeOf(buffer);
+  const sane = parsed && parsed.width > 0 && parsed.height > 0
+    && parsed.width <= 30000 && parsed.height <= 30000;
+  const size = sane ? parsed : {};
+  if (over) {
+    const entry = { filePath: '', mediaType, ...size, tooLarge: true, fetched: true };
+    registry.set(id, entry);
+    trimRegistry();
+    return { id, ...entry };
+  }
+  const ext = mediaType === 'image/jpeg' ? '.jpg'
+    : mediaType === 'image/gif' ? '.gif'
+      : mediaType === 'image/webp' ? '.webp' : '.png';
+  let filePath;
+  try {
+    const dir = path.join(os.tmpdir(), 'dsh-local-images');
+    await fs.mkdir(dir, { recursive: true });
+    filePath = path.join(dir, `${id}${ext}`);
+    await fs.writeFile(filePath, buffer);
+  } catch {
+    return null;
+  }
+  const entry = { filePath, mediaType, ...size, fetched: true };
+  registry.set(id, entry);
+  trimRegistry();
+  return { id, ...entry };
+}
+
+/**
+ * 从回环地址取回一张图片：有超时、有大小上限、必须过魔术字节。
+ *
+ * 取不到 / 不是图 / 太大 / 重定向去别处，一律返回 null，调用方保持字面 markdown ——
+ * 宁可显示成字面文本，也不能让一段历史或一帧 SSE 因为一张图取不到而挂掉（与现有口径一致）。
+ * 只走一次 GET、不跟随重定向：跟去别处就不再是「回环图片」了。
+ */
+async function fetchLoopbackImage(url) {
+  if (typeof fetch !== 'function') return null;
+  const hit = loopbackUrlCache.get(url);
+  if (hit) {
+    if (hit.id && registry.has(hit.id)) return { id: hit.id, ...registry.get(hit.id) };
+    if (!hit.id && hit.failedAt && Date.now() - hit.failedAt < LOOPBACK_FAIL_TTL_MS) return null;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), LOOPBACK_FETCH_TIMEOUT_MS);
+  let buffer;
+  try {
+    const res = await fetch(url, { signal: controller.signal, redirect: 'manual' });
+    if (!res.ok) throw new Error(`http ${res.status}`);
+    const declared = Number(res.headers.get('content-length'));
+    if (Number.isFinite(declared) && declared > MAX_IMAGE_BYTES) throw new Error('too large');
+    buffer = Buffer.from(await res.arrayBuffer());
+  } catch {
+    loopbackUrlCache.set(url, { failedAt: Date.now() });
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+  const mediaType = buffer && buffer.length > 0 && buffer.length <= MAX_IMAGE_BYTES
+    ? sniffMediaType(buffer)
+    : null;
+  if (!mediaType) {
+    loopbackUrlCache.set(url, { failedAt: Date.now() });
+    return null;
+  }
+  const entry = await registerLocalImageBytes(buffer, mediaType);
+  if (!entry) {
+    loopbackUrlCache.set(url, { failedAt: Date.now() });
+    return null;
+  }
+  loopbackUrlCache.set(url, { id: entry.id });
+  return entry;
 }
 /**
  * Markdown 里「必须保持字面」的区间：围栏代码块与行内代码。
@@ -382,9 +525,17 @@ async function inlineTextImages(text, budget) {
   let cursor = 0;
   for (const m of matches) {
     if (count <= 0) break;
+    let entry = null;
     const filePath = localImagePathOf(m[2], pool.cwd);
-    if (!filePath) continue;
-    const entry = await registerLocalImage(filePath);
+    if (filePath) {
+      entry = await registerLocalImage(filePath);
+    } else {
+      // 第二种「本机图片」：生图插件把成品图挂在自己电脑的一个回环小服务上，回的是
+      // `http://127.0.0.1:<端口>/…`。手机拿着它只会指回手机自己，所以由电脑去取回来、
+      // 按编号给手机（与磁盘图片同一条路，宽高/缓存/重试全现成）。
+      const loopbackUrl = loopbackImageUrlOf(m[2]);
+      if (loopbackUrl) entry = await fetchLoopbackImage(loopbackUrl);
+    }
     if (!entry) continue;
     count -= 1;
     pool.remaining = count;
@@ -394,82 +545,5 @@ async function inlineTextImages(text, budget) {
   }
   return cursor === 0 ? text : out + text.slice(cursor);
 }
-/**
- * Markdown 里「必须保持字面」的区间：围栏代码块与行内代码。
- *
- * 代码块里的 `![](/tmp/a.png)` 是**写法示例**而不是要画的图。旧实现整段正则替换，
- * 会把三行代码换成几十万字符的 base64——App 把这段按代码文本铺开，就成了很长很长
- * 的一块（真机现象：图片语法那块刷出几十屏，要划很久）。围栏判定与 App 的
- * `utils/markdown/parser.ts` 同口径（两边都 trim 后看 3 个以上 ` / ~）。
- */
-function literalRanges(text) {
-  const ranges = [];
-  const lines = text.split('\n');
-  const lineStarts = [];
-  let offset = 0;
-  for (const line of lines) {
-    lineStarts.push(offset);
-    offset += line.length + 1;
-  }
-  let fence = null;
-  let fenceStart = -1;
-  for (let index = 0; index < lines.length; index += 1) {
-    const line = lines[index];
-    if (fence) {
-      const close = /^(`{3,}|~{3,})[ \t]*$/.exec(line.trim());
-      if (close && close[1][0] === fence.char && close[1].length >= fence.length) {
-        ranges.push([fenceStart, lineStarts[index] + line.length]);
-        fence = null;
-      }
-      continue;
-    }
-    const open = /^(`{3,}|~{3,})/.exec(line.trim());
-    if (!open) continue;
-    fence = { char: open[1][0], length: open[1].length };
-    fenceStart = lineStarts[index];
-  }
-  // 没闭合的围栏按 App 的解析口径一直吃到文末。
-  if (fence) ranges.push([fenceStart, text.length]);
-
-  // 行内代码：同长度的反引号成对（`code`）。围栏内部的反引号已在上面标过。
-  let cursor = 0;
-  while (cursor < text.length) {
-    if (text[cursor] !== '`' || inRanges(cursor, ranges)) {
-      cursor += 1;
-      continue;
-    }
-    let ticks = 1;
-    while (text[cursor + ticks] === '`') ticks += 1;
-    let scan = cursor + ticks;
-    let closed = -1;
-    while (scan < text.length) {
-      if (text[scan] !== '`' || inRanges(scan, ranges)) {
-        scan += 1;
-        continue;
-      }
-      let run = 1;
-      while (text[scan + run] === '`') run += 1;
-      if (run === ticks) {
-        closed = scan + run;
-        break;
-      }
-      scan += run;
-    }
-    if (closed < 0) {
-      cursor += ticks;
-      continue;
-    }
-    ranges.push([cursor, closed]);
-    cursor = closed;
-  }
-  return ranges;
-}
-
-function inRanges(index, ranges) {
-  for (const [start, end] of ranges) {
-    if (index >= start && index < end) return true;
-  }
-  return false;
-}
 
 module.exports = { inlineTextImages, createTextImageBudget, localImagePathOf, hasRelativeImage, localImageOf, registerLocalImage, imageSizeOf, sniffMediaType, clearLocalImages, MAX_IMAGE_BYTES };

package/lib/mobile/stream.js

@@ -37,7 +37,7 @@ const { callSessions } = require('./rpc.js');
 const { unwrap } = require('./envelope.js');
 const { normalizeJobs } = require('./jobs.js');
 const { cutEvent, createToolNameIndex } = require('./wire-cut.js');
-const { noteLiveEvent, drainLiveSteps, liveStepsOf } = require('./live-steps.js');
+const { noteLiveEvent, drainLiveSteps, liveStepsOf, liveStepsTurnOf } = require('./live-steps.js');
 const approvals = require('./approvals.js');
 const questions = require('./questions.js');
 const streamRegistry = require('./stream-registry.js');
@@ -491,9 +491,9 @@ async function handleStream(ctx, req, res) {
    * 按 `key` 替换。**不带 seq**：它不是会话事件，不参与序门与水位（口径同 `session/queue`）。
    * 一行摘要由电脑算好 —— 推理全文与工具参数都不上线路（见 wire-cut.js）。
    */
-  const writeLiveSteps = (steps, full, frameArg) => {
+  const writeLiveSteps = (steps, full, frameArg, turn) => {
     if (!Array.isArray(steps)) return;
-    writeSse(res, { type: 'session/live-steps', sessionId, full, steps }, frameArg, { sealFrame });
+    writeSse(res, { type: 'session/live-steps', sessionId, full, turn: typeof turn === 'number' ? turn : null, steps }, frameArg, { sealFrame });
   };
 
   try {
@@ -521,8 +521,9 @@ async function handleStream(ctx, req, res) {
     // 开流先补一份过程清单：这条流从此刻起只发「变化的那几步」，之前跑过的那些靠这份快照
     // 铺出来（中途进会话 / 重连都走这里）。**一步都没有时就一个字都不发** —— 空快照只在
     // 告诉手机「你手上那份作废」，而那种情况由新的一轮开始时清（App 侧 `resetLiveSteps`）。
+    const openingTurn = liveStepsTurnOf(ctx, sessionId);
     const opening = liveStepsOf(ctx, sessionId);
-    if (!clientGone && opening.length > 0) writeLiveSteps(opening, true, null);
+    if (!clientGone && opening.length > 0) writeLiveSteps(opening, true, null, openingTurn);
 
     if (!clientGone) {
       // 写一帧并把三种结果统一收口：丢增量、需要等 drain、该收尾。
@@ -566,8 +567,10 @@ async function handleStream(ctx, req, res) {
           noteLiveEvent(ctx, sessionId, event);
           // 过程清单的增量：这一步刚开、或某一步的状态变了，把变化的那几行发出去。
           // 排在事件本身之前发顺序不影响判断（清单是「到此刻为止」的旁白，不是内容）。
+          // 带上这一轮的行号：App 按轮隔离，换轮就整份换掉（漏掉 turn/start 也不会串轮）。
+          const liveTurn = liveStepsTurnOf(ctx, sessionId);
           for (const changed of drainLiveSteps(ctx, sessionId)) {
-            const value = { type: 'session/live-steps', sessionId, full: false, steps: [changed] };
+            const value = { type: 'session/live-steps', sessionId, full: false, turn: liveTurn, steps: [changed] };
             if (await pushOrdered(value, null) === 'closed') { clientGone = true; break; }
           }
           if (clientGone) break;

package/lib/tailcat/host-process.cjs

@@ -151,7 +151,11 @@ function createTailcatHost(options) {
       if (typeof value.id !== 'string' || value.id.length > 32) return;
       if (!Array.isArray(value.allowedClients)) return;
     } else if (kind === 'error') {
-      if (typeof value.code !== 'string' || value.code.length > 64) return;
+      if (typeof value.code !== 'string') return;
+      // 助手的失败原因可能是底层网络 / 证书报错这类长串（例如取 DERP 地图时 x509 证书校验失败，
+      // 见 A3-87 的坑）。早先按「超过 64 字就丢」直接吞掉，界面于是永远停在「正在启动」、
+      // 看不到真正原因。这里只去掉控制字符、截断到上限，然后如实交给上层展示。
+      value.code = value.code.replace(/[\u0000-\u001f\u007f]+/g, ' ').trim().slice(0, 512) || 'error';
       ready = false;
     }
     options.onEvent({ ...value });

package/lib/update-install.cjs

@@ -207,6 +207,41 @@ function installedVersion(profileNodeModules, name = DEFAULT_NAME) {
   }
 }
 
+/**
+ * 这次装完后，插件「按当前平台装上的」可选依赖（例如 tailcat 平台包）各自的实际版本。
+ *
+ * 它们和插件本体一样可能刚发布就被装进来，登记排除清单时要一并写 —— 否则这些包自己的
+ * 锁条目会把后续的安装挡在 24 小时冷却窗口里（漏的正是刚发的那几个平台包）。只统计真的
+ * 落在 node_modules 里的那些：os / cpu 不匹配被包管理器跳过的平台包不登记。
+ *
+ * 读不到插件清单或读不到某个依赖都只跳过、不抛 —— 登记是善后，不该把装好的版本说成没装上。
+ */
+function installedOptionalDeps(profileNodeModules, name = DEFAULT_NAME) {
+  const readVersion = (dir) => {
+    try {
+      const raw = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+      return typeof raw.version === 'string' && raw.version ? raw.version : null;
+    } catch {
+      return null;
+    }
+  };
+  const out = [];
+  let optional;
+  try {
+    optional = JSON.parse(fs.readFileSync(path.join(profileNodeModules, name, 'package.json'), 'utf8')).optionalDependencies;
+  } catch {
+    return out;
+  }
+  if (!optional || typeof optional !== 'object') return out;
+  for (const depName of Object.keys(optional)) {
+    // hoisted 布局在 profile/node_modules 顶层；严格布局下在插件自己的 node_modules 里。
+    const version = readVersion(path.join(profileNodeModules, depName))
+      || readVersion(path.join(profileNodeModules, name, 'node_modules', depName));
+    if (version) out.push({ name: depName, version });
+  }
+  return out;
+}
+
 /**
  * profile 的依赖声明里这个包是怎么装的（`profileDir` 是 profile 根，不是它的 node_modules）。
  *
@@ -719,6 +754,13 @@ async function installLatest({
   const changed = after !== null && after !== beforeVersion;
   // 这一版是我们绕开晾置期装进去的，登记进排除清单，免得它反过来把别的安装挡 24 小时。
   const releaseAgeRecorded = changed ? recordReleaseAgeExclusion(profileDir, name, after) : false;
+  // 插件按平台带出来的可选依赖（如 tailcat 平台包）也是刚发就可能刚装上的，同批登记，
+  // 否则这些包自己的锁条目会把后续安装挡在冷却窗口里。逐条尽力写，失败不影响主结果。
+  if (changed) {
+    for (const dep of installedOptionalDeps(profileNodeModules, name)) {
+      recordReleaseAgeExclusion(profileDir, dep.name, dep.version);
+    }
+  }
   return {
     installed: changed,
     skipped: false,
@@ -845,6 +887,7 @@ module.exports = {
   installLatest,
   installLatestIfNeeded,
   installedVersion,
+  installedOptionalDeps,
   declaredSource,
   // 「Windows 上怎么起包管理器」在本机跑不起来，守卫只能验拼好的那一行，所以这两样露出来。
   cmdInvocation,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.5.22",
+  "version": "0.5.23",
   "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",
   "icon": "./icon.png",