dsh-mobile-plugin 0.5.22 → 0.5.24

package/lib/client.js

@@ -104,7 +104,7 @@ window.__ModuleLoader__.load({
      * 浏览器侧的应用路由一律写成**文档相对**形式（没有前导斜杠），与 DSH 自己的客户端
      * 一致：宿主给 index 注入了 `<base href="./">`，页面挂在哪个前缀下，请求就跟着哪个
      * 前缀走。写成 `/api/...` 这种站点根绝对地址，DSH 被反向代理挂到子路径（例如
-     * `/dsh/`）时会直接打到站点根、拿回 404 —— 现场看到的正是「读取宿主状态失败: HTTP 404」。
+     * `/dsh/`）时会直接打到站点根、拿回 404。
      */
     const DESKTOP_VIEW_ENDPOINT = 'api/relay/desktop-view';
 
@@ -739,8 +739,7 @@ window.__ModuleLoader__.load({
         }
         if (spec.title) overlay.setAttribute('aria-label', spec.title);
         // 每次重画：读数与按钮都是这一轮的现场，别留上一轮的字。
-        // **`children` 是 HTMLCollection，没有 `slice()`**（2026-11-05 真机现场：点图标一点反应都
-        // 没有，控制台一条 TypeError 就把它吞了 —— 假元素的 `children` 是数组，测试里从没红过）。
+        // **`children` 是 HTMLCollection，没有 `slice()`**（假元素是数组，测试覆盖不到）；
         // 先摊成数组再边删边走。
         for (const child of Array.from(overlay.children || [])) child.remove();
         const card = spec.wide
@@ -931,8 +930,8 @@ window.__ModuleLoader__.load({
      *
      * 为什么不能只读一次 `/status`：那条接口自己也在窗口门后面（`WEB_ACCESS_ROUTES`），
      * 窗口关着时**不是本机**的浏览器只拿得到 423。而客户端原先规定「没地址就不去开窗口」，
-     * 两边互相锁死 —— 远程用户点了只会看到「网页地址还没就绪」，没有任何顺序能走通
-     * （2026-11-03 用户报的就是这个）。所以读不到地址时正确的动作不是放弃，而是**先开窗**：
+     * 两边互相锁死 —— 远程用户点了只会看到「网页地址还没就绪」，没有任何顺序能走通。
+     * 所以读不到地址时正确的动作不是放弃，而是**先开窗**：
      * 那条开关接口本来就对同源页面豁免，开完再读一次，地址与类别就都有了。
      *
      * 地址优先用宿主给的 `panelUrl`，拿不到再用页面自己的同源地址（见 `sameOriginPanelUrl`）。
@@ -1043,7 +1042,7 @@ window.__ModuleLoader__.load({
     /** 还没问到网页地址时的重试间隔。取到就停，不再问。 */
     const FOOTER_URL_RETRY_MS = 20000;
     /**
-     * 手机图标（用户 2026-11-02 从八个候选里挑的「刘海 + 底条」那一款）：24 画布描边，
+     * 手机图标（「刘海 + 底条」那一款）：24 画布描边，
      * 机身 6.2→17.8、圆角 2.8，顶上一条刘海、底下一条家条。比早先那版机身更满一点，
      * 因为窄高的形状按名义尺寸画出来会比旁边的方形图标显小。
      */
@@ -1053,7 +1052,7 @@ window.__ModuleLoader__.load({
       'M11 19.4h2',
     ];
     /**
-     * 告警态那颗红点（用户 2026-11-05 从四个候选里拍的「整颗转红 + 右上角一颗点」那一款）。
+     * 告警态那颗红点（「整颗转红 + 右上角一颗点」那一款）。
      *
      * 圆心在机身右上角外侧：左缘压住右上那圈圆角（机身右边到 17.8），两块同色连成一整块，
      * 所以不用再抠一圈背景色的缝隙。24 画布内放得下——最右到 22，不越界。
@@ -1062,11 +1061,11 @@ window.__ModuleLoader__.load({
      */
     const PHONE_ALERT_DOT = { cx: 18.9, cy: 5, r: 3.1 };
     /**
-     * 图标边长：展开那一行 20，窄条里的圆钮 22（用户 2026-11-02 拍的，先 18 后嫌小又抬了一档）。
+     * 图标边长：展开那一行 20，窄条里的圆钮 22。
      *
      * 那一行的账号按钮高 44、里面真正画出来的只有 24 的头像，同行其它图标是 16。20 是
      * 28 的按钮里还能四边各留 4 像素的上限；窄条那颗放进 36 的圆钮里，用 22。
-     * 别再往回调 16 / 18：手机图形窄，按名义尺寸画出来比同行的方形图标显小，用户两次都说小。
+     * 别再往回调 16 / 18：手机图形窄，按名义尺寸画出来比同行的方形图标显小。
      * 真要再大，得连按钮一起撑到 30 以上——那一行其它按钮都是 28，会开始抢。
      */
     const PHONE_GLYPH_WIDE = 20;
@@ -1116,8 +1115,8 @@ window.__ModuleLoader__.load({
      * 把「打开哪一页 / 现在能不能点」同步到元素上。
      *
      * 没有地址时**不写 href**（没有地址可写，别挂死链），但**点击处理照样挂上**：那颗图标的
-     * 点击会自己去把两小时窗口开出来、再读一次地址（见 `openConfigurationPage`）。原先这里
-     * 把 `onclick` 一起摘掉，现场就是「点了完全没反应」——2026-11-03 用户报的正是这个。
+     * 点击会自己去把两小时窗口开出来、再读一次地址（见 `openConfigurationPage`）。别把
+     * `onclick` 一起摘掉 —— 摘了就是「点了完全没反应」。
      *
      * 地址、网络类别和窗口状态都由 effect 往上同步，组件重渲染不会把它丢掉。
      */
@@ -1172,7 +1171,7 @@ window.__ModuleLoader__.load({
      * 就画在 `sidebar.footer.action` 自己那一行（居中摞在设置上方）——这一条是物理限制，
      * 不是退路。认不出那一行的时候也走这条路，入口不会消失。
      *
-     * 点下去做什么（2026-11-02 用户拍板）：宿主在 `/status` 上按请求 Host 报一个
+     * 点下去做什么：宿主在 `/status` 上按请求 Host 报一个
      * `panelScope`，图标据此分流：
      *   - `loopback`：人就在这台机器的 DSH 里，控制面本来就认它 —— 普通链接跳转；
      *   - `private` / `public`：浏览器是从别的机器来的，控制面不认它、面板会回 423，
@@ -1253,9 +1252,9 @@ window.__ModuleLoader__.load({
        * 只有**网页**（`http(s)`）才需要这一手：桌面壳里那个函数一定被拒，见 `isWebPage`。
        */
       /**
-       * 点下去做什么（2026-11-05 用户要求改过一次）。
+       * 点下去做什么。
        *
-       * **从「点了就跳浏览器」改成「点了先在这一页弹一屏」**：用户遇到问题时最缺的不是
+       * **点了先在这一页弹一屏**（不是直接跳浏览器）：用户遇到问题时最缺的不是
        * 跳过去，而是「它现在到底哪一环断了」——启动、装载、隧道、旁挂进程、自检全都在那一屏
        * 里，比一个打不开的页面有用。跳转本身没取消，挪进了那一屏里的一颗按钮。
        *
@@ -1344,9 +1343,9 @@ window.__ModuleLoader__.load({
         };
 
         /**
-         * 第一层：**只有一个简单入口**（2026-11-05 用户要求）。
+         * 第一层：**只有一个简单入口**。
          *
-         * 原来点图标一上来就是整屏读数，太重了 —— 绝大多数时候人只是想去配置页，或者去看
+         * 一上来就整屏读数太重 —— 绝大多数时候人只是想去配置页，或者去看
          * 手机为什么连不上。所以这一层只摆两块：左边「进入控制台」（= 原来那个跳转），
          * 右边「报错调试」（才进第二层那一屏）。
          */
@@ -1796,9 +1795,9 @@ window.__ModuleLoader__.load({
     }
 
     /* ── 设置里的那一项「移动端」───────────────────────────────────────────
-     * 用户 2026-11-03 要求加回来：介绍产品时说的入口就是「设置 → 移动端」，2026-11-02 那一版
-     * 把它整块下线、只留侧边栏那颗图标，于是从网页版进来的人不知道配置在哪。现在两项都在，
-     * 它们进的是同一个页面、走同一条拨号链路（图标是快捷方式，这一张是设置里的正规入口）。
+     * 设置里的「移动端」与侧边栏那颗图标进的是同一个页面、走同一条拨号链路（图标是快捷方式，
+     * 这一张是设置里的正规入口）：介绍产品时说的入口就是「设置 → 移动端」，只留图标会让从
+     * 网页版进来的人不知道配置在哪。
      *
      * 刻意只有一张薄卡：界面本体全在网页版里（A3-37），在这里再画一套等于长期维护第二套 UI，
      * 而两套迟早会打架。卡片只做两件事——说清配置在哪、把那一页开出来；开不出来就在卡上写原因。

package/lib/impl.js

@@ -32,7 +32,7 @@ const { lanUrls, advertisedCandidates, phoneCandidates, ipv6Candidates, withManu
 // 配对二维码的载荷：面板与终端命令共用一份，拼装在 `./relay/pairing-payload.cjs`。
 const { pairingPayload, pairingText } = require('./relay/pairing-payload.cjs')
 const { resolvePort } = require('./relay/port-allocator.cjs')
-const { mountTailcat } = require('./tailcat/wiring.cjs') // 直连隧道：入口 + 助手会话 + 启停
+const { mountTailcat, chooseTailcatTarget } = require('./tailcat/wiring.cjs') // 直连隧道：入口 + 助手会话 + 启停
 const { createPreviewService } = require('./relay/preview.js')
 const { mountTerminal, mountCli } = require('./mobile/services.js')
 // 手机打开「电脑上的网页版」时用的那枚一次性登录令牌（见 mobile/host-web.js）。
@@ -304,7 +304,7 @@ function apply(ctx) {
   const lanPortInUse = () => (state.lanEnabled && effectiveLanPort > 0 ? effectiveLanPort : state.lanPort)
   const advertisedLanPort = () => (state.lanEnabled ? sidecarLifecycle.getAdvertisedLanPort() : state.lanPort) // 对外报地址用实绑端口，见 lifecycle
   // 直连隧道：不配中转也能连的兜底通道；挂不上就只是没这条通道，中转与局域网照旧。
-  const tailcat = mountTailcat({ mount, warn, state, saveState: core.saveState, lanPortInUse, hostName: () => state.name, ctx, name })
+  const tailcat = mountTailcat({ mount, warn, state, saveState: core.saveState, targetPort: chooseTailcatTarget({ lanEnabled: () => state.lanEnabled, lanPort: lanPortInUse, webPort: () => ctx.webServer.port }), hostName: () => state.name, ctx, name })
   // 每次同步前都跑一次探测，而不是只在启动时探一次：`/api/relay/config` 改了
   // lanPort 之后同样要走这条路（否则新端口被占时又会退回死地址）。并发调用复用
   // 在飞的那次——探测要占一个监听句柄，重复触发没有意义。

package/lib/mobile/cli/mobile.js

@@ -3,34 +3,10 @@
 /**
  * `cli-*` 会话的移动端适配层：让一条 CLI 对话走宿主普通会话那一整套接口。
  *
- * CLI 会话不是宿主的会话 —— 它是一条 ACP 子进程，块表在 `cli/blocks.js` 里。但对手机来说
- * 它必须长得跟普通会话一模一样：出现在侧栏列表里、点进去有历史、能发、能停、能选模型、
- * 会弹审批卡。所以这一层只做两个方向的翻译，不新造任何接口：
- *
- *   1. **请求方向**：`sessionId` 以 `cli-` 开头的，路由层先看一眼再交给这里（见
- *      `lib/routes/mobile-api.js`）。`sessionId` 在查询串（GET）或请求体（POST）里，所以
- *      分派只发生一次，不抄任何 handler。
- *   2. **帧方向**：ACP 的块表 → 宿主那套 `session/event` 帧。App 认哪几种、缺哪个就转圈，
- *      是按 `app/src/hooks/streamFrame.ts` 与 `app/src/utils/frameWatermark.ts` 逐条对出来的：
- *      `turn/start` / `turn/end` / `user/message` / `assistant/chunk` / `tool/result` /
- *      `approval/*` / `session/title` / `session/heartbeat`。
- *
- * 三条刻意的减法（都比着「App 到底靠什么落地」做的，不是省事）：
- *
- *   - **正文与工具的过程用草稿帧，落定的内容一律走历史。** 草稿（`assistant/chunk`）不需要
- *     seq、不会被序门丢掉；一轮结束先发 `turn/end`（reason=completed），再把这一轮每个块
- *     以稳定 id 发一条 `assistant/message`。id 与 `/session/messages` 的行 id 是同一个
- *     （块的 id），所以重连 / resync 按 id 合并，不会出现两遍。`assistant/message` 放在
- *     `turn/end` **之后**：App 在「当前回合」收尾时会把这条消息当成终局消息再收一次尾，
- *     先发 turn/end 就只是就地更新，不会提前把这一轮判成结束。
- *   - **审批卡照抄宿主那一种形状**（帧级 `rpcId` + payload `approvalId`，见 `approvals.js`）。
- *     App 只认这种卡；新造一种等于卡片永远不出现。回答仍走 `/approval/respond`，在这一层
- *     按 rpcId 找回 ACP 的挂起项。
- *   - **拿不到的字段给合理缺省，不报错。** 模型目录拿不到就回只有一项的清单；统计、队列、
- *     搜索这类一律回空；这条会话在每种接口上都可用，比「主链路通了、点别的报错」重要。
- *
- * 会话本身仍归 `cli/service.js` 托管（进程、块表、审批挂起项都在那儿），这里只拿它的
- * 只读门面。
+ * CLI 会话不是宿主会话，而是一条 ACP 子进程（块表在 `cli/blocks.js`），但对手机必须长得跟普通会话一样：侧栏有它、点进去有历史、能发能停能选模型会弹审批卡。所以这一层只做两个方向的翻译、不新造接口：
+ *   请求方向：`sessionId` 以 `cli-` 开头时路由层先看一眼再交给这里（见 `lib/routes/mobile-api.js`），分派只发生一次。
+ *   帧方向：ACP 块表 → 宿主 `session/event` 帧（帧种类按 App 实际认的对齐）。
+ * 三条刻意减法：过程走草稿帧（`assistant/chunk`）、落定内容一律走历史（`assistant/message` 放在 `turn/end` 之后）；审批卡照抄宿主形状（帧级 `rpcId` + payload `approvalId`，见 `approvals.js`）；拿不到的字段给合理缺省不报错。会话本身仍归 `cli/service.js` 托管。
  */
 
 const fs = require('node:fs')

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/pairing.js

@@ -12,6 +12,11 @@
  * 请求体两种形状都认：老 App 的 `{ instanceId?, code, device }` 明文照旧；协议 v2 的
  * `{ instanceId, sealed }` 没有配对码，票据本身就是资格证明，回包同样是密文 —— 里面是
  * token / cookie / 设备凭据，明文回包等于让中转拿到这台设备的长期通行证。
+ *
+ * 协议 v2 的请求体还多了个可选 `ticketId`（批量同步导入用，见 docs/device-batch-sync.md）：
+ * 有它就从一次性券表（`mobile/transfer-tickets.js`）取那张券当票据，配成功后 `consume` 作废；
+ * 没有就沿用 `state.pairingTicket`（电脑面板二维码那条路，行为不变）。券由导出方手机向目标
+ * 电脑申领、塞进二维码，所以票据不再只能是面板上那一张 —— 这是本文件相对旧签名的唯一变化。
  */
 
 const { sendJson } = require('../shared/http-util');
@@ -103,10 +108,11 @@ function readBody(req) {
  * @param {(port: number) => Array<object>} [deps.lanCandidates] 直连候选（与 `/connection-info` 同一份）
  * @param {(port: number) => Array<object>} [deps.ipv6Candidates] IPv6 直连候选
  * @param {() => number} [deps.lanPort] 宿主实绑的直连端口（配置端口被占时会换）
+ * @param {object} [deps.transferTickets] 一次性券表（transfer-tickets.js）；有它才认 `ticketId`
  * @param {(message: string) => void} deps.log
  */
 function createPairHandler(deps) {
-  const { state, core, credentials, pairingApproval, lanCandidates, ipv6Candidates, lanPort, log } = deps;
+  const { state, core, credentials, pairingApproval, lanCandidates, ipv6Candidates, lanPort, transferTickets, log } = deps;
   /**
    * 配对成功之后换掉配对码与票据（§5.1）。
    *
@@ -168,9 +174,34 @@ function createPairHandler(deps) {
     let supplied;
     let issuedExtra;
     let pairKey = null;
+    // 这次配对若用的是一次性券，记下它的 ticketId，配成功后立刻作废；面板票据那条路留 null
+    // （它靠 rotatePairing 换码换票据，不是靠这里 consume）。
+    let ticketIdToConsume = null;
     if (isSealedShape) {
+      // 票据来源：带 ticketId 就从一次性券表取（批量同步导入）；否则沿用面板那张 state 票据。
+      const ticketId = typeof body.ticketId === 'string' ? body.ticketId.trim() : '';
+      let ticket = state.pairingTicket;
+      if (ticketId) {
+        ticket = transferTickets && typeof transferTickets.resolve === 'function'
+          ? transferTickets.resolve(instanceId, ticketId)
+          : null;
+        // 券不存在 / 过期 / 已用：与「配对码错误」同形拒绝，不给探测空间。
+        // 券不存在 / 过期 / 已用：与「配对码错误」不同，这里可以点明 —— 券是不可猜的随机串
+        // （不像六位配对码能逐位试），明说「用过或过期，请另一台手机重新导出」不给出探测空间，
+        // 又能让批量导入方一眼知道该干什么，而不是对着一句「配对码错误」去重扫。
+        if (!ticket) {
+          throttle.noteFail();
+          sendJson(res, 401, {
+            ok: false,
+            code: 'transfer-ticket-invalid',
+            error: '这个二维码已被使用或已过期，请让导出方那台手机重新导出后再扫',
+          });
+          return;
+        }
+        ticketIdToConsume = ticketId;
+      }
       const opened = openSealedPairRequest({
-        ticket: state.pairingTicket,
+        ticket,
         instanceId,
         sealed,
         claimedInstanceId: typeof body.instanceId === 'string' ? body.instanceId : '',
@@ -225,8 +256,17 @@ function createPairHandler(deps) {
       return;
     }
 
-    // 成功签发之后立刻换码 + 换票据：谁截了二维码，那张图从这一刻起就没有用了。
-    if (rotatePairing) {
+    // 成功签发之后立刻作废资格：
+    //  · 用一次性券配的 → consume 那张券（同一张配不了第二台手机）；面板的码与票据不动，
+    //    因为这次配对根本没用到它们、也不该让别人的面板二维码跟着失效。
+    //  · 面板二维码那条老路 → 换码 + 换票据（谁截了那张图，从这一刻起就没有用了）。
+    if (ticketIdToConsume && transferTickets && typeof transferTickets.consume === 'function') {
+      try {
+        transferTickets.consume(instanceId, ticketIdToConsume);
+      } catch (error) {
+        log('pair ticket consume failed:', error && error.message);
+      }
+    } else if (rotatePairing) {
       try {
         rotatePairing();
       } catch (error) {