dsh-mobile-plugin 0.1.99 → 0.2.0

package/lib/mobile/approvals.js

@@ -19,9 +19,12 @@
  *      哪条回答通道都不影响它），本桥据此铸一个自己的 rpcId 并把卡推给正在看这个会话的
  *      手机。approvalId 直接用宿主自己的 id —— App 靠它把 `approval/decided` 对上、自动
  *      收掉那张卡。
- *   2. 听 `approval/request` 钩子（**prepend**，见下）：把这台手机挂成候选人并和下游竞速。
- *      下游（桌面窗口 / ACP / 宿主默认的 fail-closed）照旧拿到请求、卡片照旧出现，
- *      手机答得早就用手机的，桌面答得早就用桌面的，输的那张卡由结算帧收掉。
+ *   2. 听 `approval/request` 钩子（**prepend**，见下）：把这台手机挂成候选人。手机没在看
+ *      这个会话时与下游竞速：下游（桌面窗口 / ACP / 宿主默认的 fail-closed）照旧拿到请求、
+ *      卡片照旧出现，手机答得早就用手机的，桌面答得早就用桌面的，输的那张卡由结算帧收掉。
+ *      手机**正在看**这个会话时则不转发，由手机独家作答 —— 桌面那张卡挂在被转发的请求上，
+ *      本桥没有替它收尾的口子，转发出去、手机先答，桌面那张就永远悬着（2026-10-23，
+ *      与提问桥同一条坑）。
  *   3. `/approval/respond` 拿 rpcId 找到挂起项，把结论交回钩子 —— 这才是真正让 agent
  *      继续往下跑的那一步。
  *
@@ -263,16 +266,23 @@ function bindRequest(entry, request) {
 /**
  * 挂起这条请求直到有人给结论。
  *
- * 下游**先叫**：`next()` 一调，桌面窗口那张卡照旧出现（这条路径的行为一字不改）。手机答得
- * 早就用手机的；下游答得早就用下游的 —— 谁先给结论谁算数，输的那张卡由结算帧收掉。
- * 两边都没人答时这里会一直挂着，和今天宿主自己的行为一致（审批本来就等人工）。
+ * 传了 `next` 就与下游竞速（手机没在看这个会话时的路径）：`next()` 一调，桌面窗口那张卡
+ * 照旧出现。手机答得早就用手机的；下游答得早就用下游的 —— 谁先给结论谁算数，输的那张卡
+ * 由结算帧收掉。两边都没人答时这里会一直挂着，和今天宿主自己的行为一致（审批本来就等人工）。
+ *
+ * **不传 `next`（手机正在看这个会话）就是手机独家作答**：不往下游转发，桌面从源头就不弹卡
+ * ——桌面那张卡挂在「被转发的请求」上，而本桥没有替那条请求收尾的口子（收尾权在宿主网关
+ * 手里），手机答完它只会永远悬着，与提问桥同一条坑（2026-10-23）。独家作答后结论照常走
+ * `approval/decided` 落进会话记录，桌面看得到裁决结果，只是没有可点的卡。
  */
 function holdForPhone(entry, next) {
-  const downstream = Promise.resolve().then(() => next()).then((outcome) => {
-    const value = DECISIONS.has(outcome) ? outcome : 'unavailable';
-    settle(entry, value);
-    return value;
-  });
+  const downstream = next === undefined
+    ? new Promise(() => {})
+    : Promise.resolve().then(() => next()).then((outcome) => {
+      const value = DECISIONS.has(outcome) ? outcome : 'unavailable';
+      settle(entry, value);
+      return value;
+    });
   return Promise.race([entry.wait.then((result) => result.outcome), downstream]);
 }
 
@@ -286,7 +296,9 @@ function onApprovalRequest(request, next) {
     reason: typeof request.reason === 'string' ? request.reason : undefined,
   }, { unboundOnly: true });
   bindRequest(entry, request);
-  return holdForPhone(entry, next);
+  // 手机正在看这个会话就不往下游转发（不传 next）：桌面从源头不弹卡，由手机独家作答。
+  // 没有观众时照旧竞速，纯桌面使用一字不改。
+  return holdForPhone(entry, watcherCount(sessionId) > 0 ? undefined : next);
 }
 
 /**
@@ -315,6 +327,10 @@ function installApprovalBridge(ctx) {
  *
  * 先查本桥的挂起项；查不到就交回 `ctx.apiProxy.respond`（0.1.x 宿主那份真 apiProxy 才是
  * 它的归宿；0.2.x 的兼容桥会如实回 `host-unsupported`，于是落到下面那条 409）。
+ *
+ * `respond` 的返回形态两条通道不同（0.1.x 是 Promise、0.2.x 兼容桥是同步对象），
+ * 所以这里不能直接 `.catch()` —— 同步对象上没有这个方法，会抛 TypeError 被路由守卫
+ * 兜成 500。详见 `mobile/questions.js` 的 `respondViaLegacyProxy`，两处同一口径。
  */
 async function handleApprovalRespond(ctx, req, res) {
   const body = await readJsonBody(req);
@@ -330,17 +346,48 @@ async function handleApprovalRespond(ctx, req, res) {
     settle(entry, body.outcome);
     return sendJson(res, 200, { ok: true, accepted: true });
   }
-  const receipt = await ctx.apiProxy.respond({
+  const receipt = await respondViaLegacyProxy(ctx, {
     type: 'client-response',
     rpcId: body.rpcId,
     result: { ok: true, value: { sessionId: body.sessionId, approvalId: body.approvalId, outcome: body.outcome } },
-  }).catch(() => null);
+  });
   if (!receipt || receipt.accepted !== true) {
-    return sendJson(res, 409, { ok: false, error: { code: 'not-pending', message: '该审批已完成或不可回答' } });
+    // 本桥不认识、旧通道也不认：这条审批在**我们这一侧**已经死了（挂起项只活在进程内，
+    // 插件重载 / 宿主重启就没了）。
+    //
+    // 与提问桥同一口径（见 questions.js 同位置）：**不推结算帧**。手机端要靠这张卡把
+    // 失败原因写出来（`ApprovalPanel` 的 error 行），卡一收掉就跟着卸载，那句话没地方落。
+    return sendJson(res, 409, {
+      ok: false,
+      error: {
+        code: 'not-pending',
+        message: '这条审批已经不在等待结论（插件重载或宿主重启后挂起的审批会失效），请回桌面端处理。',
+      },
+    });
   }
   sendJson(res, 200, { ok: true, accepted: true });
 }
 
+/**
+ * 把结论交回旧通道的 `ctx.apiProxy.respond`，**Promise 与同步对象两种返回都收**。
+ *
+ * 两条通道形态不同：0.1.x 的真 apiProxy 回 Promise，0.2.x 的兼容桥
+ * （`mobile/host-bridge.js`）回同步的 `{result:{ok:false,error:{code:'host-unsupported'}}}`——
+ * 同步对象上没有 `.catch`，早先直接链 Promise 会在 0.2.x 抛 TypeError、被路由守卫兜成 500。
+ * 抛错与「通道说不认」一律折算成 null，调用方据此如实回 409。
+ */
+async function respondViaLegacyProxy(ctx, message) {
+  const proxy = ctx && ctx.apiProxy;
+  if (!proxy || typeof proxy.respond !== 'function') return null;
+  try {
+    const reply = proxy.respond(message);
+    const settled = await reply;
+    return settled && typeof settled === 'object' ? settled : null;
+  } catch {
+    return null;
+  }
+}
+
 module.exports = {
   installApprovalBridge,
   handleApprovalRespond,

package/lib/mobile/auth.js

@@ -1,15 +1,18 @@
 'use strict';
 
 /**
- * dsh-mobile 鉴权：移动 token 校验（HMAC，与中转同构）。
+ * dsh-mobile 鉴权：每设备凭据（T1）查库 + 旧 HMAC token 兜底。
  *
- * token 格式 <instanceId>.<exp>.<hmac(lanSecret)>，算法/常数时间比较收在
- * ../shared/dshtoken.js；本模块保留原公开导出面、内部改调共享实现。
+ * 新配对只发一枚 `<instanceId>.<exp>.<random>`，它同时是 Bearer、
+ * `dsh_lan` cookie 与 `X-Dsh-Device-Credential`。服务端按整串的 sha256 查凭据库，
+ * **查到就以记录为准**（吊销 / 过期立即拒绝，不再回退）；查不到才回退到旧的
+ * `<instanceId>.<exp>.<hmac(lanSecret)>` 无状态令牌 —— 那条只为升级前配过的老 App 保留。
+ *
+ * 顺序（凭据头 → Bearer → 旧 HMAC）是这里唯一要紧的东西。允许「本机签发的凭据被吊销后
+ * 回退去验 HMAC」等于吊销永远不生效：那个 HMAC token 一年有效。
  */
 
 const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
 
 const sharedToken = require('../shared/dshtoken');
 const credentials = require('../shared/credentials-entry.js').credentialsEntry();
@@ -28,7 +31,7 @@ function loadRelayState() {
   }
 }
 
-/** 校验移动 token：格式 <instanceId>.<exp>.<hmac(lanSecret)>，且 instanceId 与当前实例一致。 */
+/** 校验旧的无状态移动 token：`<instanceId>.<exp>.<hmac(lanSecret)>`。 */
 function verifyMobileToken(token) {
   if (!token) return false;
   const state = loadRelayState();
@@ -37,42 +40,59 @@ function verifyMobileToken(token) {
 }
 
 /**
- * 请求出示的设备凭据（`dshc_…`），取不到返回 null。
+ * 请求出示的凭据原文，取不到返回 null。
  *
- * App 把设备凭据放在独立的 `X-Dsh-Device-Credential` 头里，`Authorization` 留给
- * 宿主 token；`Authorization` 分支仅用于兼容早期客户端。
+ * 接受**任意非空串**，不再只认 `dshc_` 前缀：协议 v2 的 T1 是 `<实例号>.<exp>.<随机>`，
+ * 旧版是 `dshc_…`，升级前的老 App 还有 HMAC Bearer —— 三种都从这里过，由查库结果决定
+ * 走哪条路。App 把设备凭据放在独立的 `X-Dsh-Device-Credential` 头里、`Authorization`
+ * 留给宿主 token；`Authorization` 分支是给「只有一枚 Bearer 的旧客户端」的兜底。
  */
 function presentedCredential(req) {
   const raw = req.headers['x-dsh-device-credential'];
   const header = Array.isArray(raw) ? raw[0] : raw;
-  if (typeof header === 'string' && header.startsWith('dshc_')) return header;
+  if (typeof header === 'string' && header.trim()) return header.trim();
   const m = /^Bearer\s+([^\s]+)$/.exec(req.headers.authorization || '');
-  return m && m[1].startsWith('dshc_') ? m[1] : null;
+  return m ? m[1] : null;
+}
+
+/** 请求是否持有有效凭据。 */
+function authorized(req) {
+  return authOutcome(req).ok;
 }
 
 /**
- * 请求是否持有有效凭据。两条路径：
- *  1) `Authorization: Bearer <instanceId>.<exp>.<hmac>` —— 与中转同构的 HMAC token；
- *  2) `X-Dsh-Device-Credential: dshc_…` —— 宿主本机凭据库中按 instanceId 核对。
+ * 鉴权结果，**带上「为什么被拒」**（§3.8）。
+ *
+ * 只回 `true/false` 的话，被吊销的手机看到的永远是「请求失败（HTTP 401）」——用户既不知道
+ * 自己是被踢了，也不知道该重新扫码。所以判定分三种：通过、被吊销、已过期。
  *
- * 顺序是这里唯一的要点。出示了**本机签发过**的设备凭据时必须以它为准：一经吊销
- * 或过期立即拒绝，不再回退到无状态 token。HMAC token 有效期一年，若允许回退，
- * 吊销就永远不生效，第 2 条也就形同虚设。
+ * 通过时顺手 `renew`（§3.9 的滑动续期）并交出记录：装配层的 `onAuthorized` 拿它记
+ * 「最近连接」，两件事都只在鉴权通过后才有意义。
  *
- * 「本机不认识这张凭据」则必须回退：公网配对时凭据由中转签发、存在中转的凭据库
- * 里（`dsh-mobile-server/lib/tunnel-handler.js`），宿主这里查不到；若一律拒绝，
- * 「公网配对后回到局域网直连」会直接 401。
+ * @returns {{ ok: true, record?: object }
+ *          | { ok: false, reason: 'revoked' | 'expired' | 'unauthorized' }}
  */
-function authorized(req) {
+function authOutcome(req) {
   const presented = presentedCredential(req);
   if (presented) {
     const state = loadRelayState();
-    if (!state || !state.instanceId) return false;
-    const known = credentials.lookup(presented, state.instanceId);
-    if (known) return credentials.isLive(known);
+    if (state && state.instanceId) {
+      const known = credentials.lookup(presented, state.instanceId);
+      if (known) {
+        if (known.revokedAt) return { ok: false, reason: 'revoked' };
+        if (known.expiresAt && known.expiresAt <= Date.now()) return { ok: false, reason: 'expired' };
+        // 还剩不到一半就顺手续期：所有设备会在同一天集体掉线，而这件事完全可以用一次
+        // 现成的调用避免 —— 用户不需要为此做任何事。
+        try { credentials.renew(known); } catch { /* 续期失败不影响这一次请求 */ }
+        return { ok: true, record: known };
+      }
+      // 查不到就是「本机没签发过它」：可能是中转签的凭据（那条库在中转那边），也可能是
+      // 升级前的 HMAC token。两种都往下走旧令牌校验，不在这里判死。
+    }
   }
   const m = /^Bearer\s+([^\s]+)$/.exec(req.headers.authorization || '');
-  return Boolean(m && verifyMobileToken(m[1]));
+  if (m && verifyMobileToken(m[1])) return { ok: true };
+  return { ok: false, reason: 'unauthorized' };
 }
 
-module.exports = { loadRelayState, presentedCredential, verifyMobileToken, authorized };
+module.exports = { loadRelayState, presentedCredential, verifyMobileToken, authorized, authOutcome };

package/lib/mobile/credential-upgrade.js

@@ -0,0 +1,129 @@
+'use strict';
+
+/**
+ * 旧凭据原地升级：把协议 v1 的会话（HMAC 令牌 / 只带配对码的 `dshc_`）换成带设备主密钥的
+ * T1，让一台早就配好的手机不用重新扫码就能开始加密。
+ *
+ * **主密钥以手机为准**（2026-10-24 修）：手机在本地生成 `deviceKey` 与 `keyId`，这次升级
+ * 请求里明文带上，宿主原样存进凭据库、把同一个 `keyId` 回给手机。宿主**不能**自己生成
+ * 一把再回标识 —— 那会让两端各拿一把钥匙，升级完手机立刻按 v2 封请求，而宿主用另一把
+ * 验签，之后每一条请求都是 `e2ee-bad-signature`，比不升级更糟。
+ *
+ * 明文上行是一次性的取舍：老会话手上只有旧凭据，既没有二维码里那张票据，也没有任何别的
+ * 保密通道（局域网直连与公网 IPv6 直连都是明文 HTTP，中转本来就按「不可信的那一跳」设计）。
+ * 不这么做就只能让用户重新扫一次码。升级之后所有流量仍由这把钥匙端到端加密。
+ *
+ * 换成什么不在本次判断里：拿到完整一套（凭据 + 密钥 + 标识）才回补丁，缺一样就当没升级。
+ */
+
+const crypto = require('node:crypto');
+const { sendJson } = require('../shared/http-util.js');
+const { DEVICE_KEY_RE, KEY_ID_RE } = require('../shared/e2ee-pair.js');
+
+/** 请求出示的设备凭据：独立头优先，`Authorization` 只用于兼容早期客户端。 */
+function presentedCredential(req) {
+  const header = req.headers && req.headers['x-dsh-device-credential'];
+  if (typeof header === 'string' && header) return header;
+  const match = /^Bearer\s+([^\s]+)$/.exec(String((req.headers && req.headers.authorization) || ''));
+  return match ? match[1] : null;
+}
+
+/** 手机这次带上来的密钥材料；没带或形状不对都返回 null。 */
+function deviceSecretOf(body) {
+  if (!body || typeof body !== 'object') return null;
+  const device = body.device && typeof body.device === 'object' ? body.device : {};
+  const pick = (key) => {
+    const top = body[key];
+    if (typeof top === 'string' && top) return top;
+    const inner = device[key];
+    return typeof inner === 'string' && inner ? inner : '';
+  };
+  const deviceKey = pick('deviceKey');
+  const keyId = pick('keyId');
+  if (!deviceKey && !keyId) return null;
+  return { deviceKey, keyId };
+}
+
+/**
+ * 处理 `POST /api/mobile/v1/device-credential/upgrade`。
+ *
+ * @param {object} req
+ * @param {object} res
+ * @param {{ instanceId: string, store: object, log?: Function }} deps
+ */
+function handleCredentialUpgrade(req, res, deps) {
+  const instanceId = String((deps && deps.instanceId) || '');
+  const store = deps && deps.store;
+  if (!store) return sendJson(res, 503, { ok: false, error: { code: 'unavailable', message: '凭据库不可用' } });
+
+  const presented = presentedCredential(req);
+  const record = presented ? store.lookup(presented, instanceId) : null;
+  const body = req.body && typeof req.body === 'object' ? req.body : {};
+  const meta = body.device && typeof body.device === 'object' ? body.device : body;
+  const deviceId = String(meta.deviceId || meta.id || (record && record.deviceId) || '');
+
+  const secret = deviceSecretOf(body);
+
+  // 没带密钥材料：只可能是旧客户端或它没准备好。已经在 T1 上的顺手续期并如实回一句
+  // 「没换东西」；还在 v1 上的什么都不动 —— 宿主不代生成密钥（见文件头）。
+  if (!secret) {
+    if (record && record.deviceKey && record.keyId) {
+      store.renew(record);
+      return sendJson(res, 200, {
+        ok: true,
+        upgraded: false,
+        proto: 2,
+        instanceId,
+        token: presented,
+        cookie: `dsh_lan=${presented}`,
+        deviceCredential: presented,
+        keyId: record.keyId,
+        deviceId: record.deviceId,
+        credentialExpiresAt: record.expiresAt || null,
+        serverTime: Date.now(),
+      });
+    }
+    return sendJson(res, 200, {
+      ok: true,
+      upgraded: false,
+      proto: 1,
+      instanceId,
+      token: presented || '',
+      cookie: presented ? `dsh_lan=${presented}` : '',
+      deviceCredential: presented || '',
+      deviceId,
+      serverTime: Date.now(),
+    });
+  }
+
+  // 带了却不合形状：这是实现错了，不是「还没准备好」。写进凭据库会变成一台永远验不过的
+  // 设备，所以当场拒掉。
+  if (!DEVICE_KEY_RE.test(secret.deviceKey) || !KEY_ID_RE.test(secret.keyId)) {
+    return sendJson(res, 400, {
+      ok: false,
+      error: { code: 'bad-device-secret', message: 'deviceKey / keyId 形状不对' },
+    });
+  }
+
+  const issued = store.issue(instanceId, { ...meta, deviceId }, '', undefined, {
+    deviceKey: secret.deviceKey,
+    keyId: secret.keyId,
+  });
+  // 旧记录**不立刻吊销**：无法确认手机真的把新的存下来了，立刻吊销会把一台正常设备锁在
+  // 门外。让它自然过期，期间它仍走旧 HMAC 兜底那条路。
+  return sendJson(res, 200, {
+    ok: true,
+    upgraded: true,
+    proto: 2,
+    instanceId,
+    token: issued.credential,
+    cookie: `dsh_lan=${issued.credential}`,
+    deviceCredential: issued.credential,
+    keyId: secret.keyId,
+    deviceId: issued.deviceId,
+    credentialExpiresAt: issued.expiresAt,
+    serverTime: Date.now(),
+  });
+}
+
+module.exports = { handleCredentialUpgrade, presentedCredential, deviceSecretOf };

package/lib/mobile/entry-window.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ * 入口窗口的取数参数（`GET /session/messages?thin=1`，只对不带 beforeSeq / afterSeq 的
+ * 一次性入口窗口生效；往上翻页与增量补拉保持完整）。
+ *
+ * 宿主 paginate 认 `turnWindow`：给 `minMessages` / `minTurns` 两个下限，它往回跨过至少
+ * 这么多条消息、这么多轮 turn/start 之后，停在**一轮的开头**。入口要的正是这个边界 ——
+ * 按条数硬切会切在一轮中间，长回合（每步一条 assistant 消息）里用户自己那句话就被挤出
+ * 窗口了，进对话看到的只剩这一轮的后半段。
+ *
+ * `maxMessages` 是宿主的硬上限，量的是**消息条数**（含过程步）。按轮取整时它必须大于
+ * 「一轮最多能有多少步」，否则截断点仍落在一轮中间、边界又回到按条数切。
+ *
+ * 2000 不是随手取的上限：本机 1420 个真实回合量下来，最长一轮 576 条消息、超过 500 的
+ * 有 3 个、超过 200 的有 18 个。它只是**上界**，宿主在跨过 `minTurns` 且遇到 turn/start
+ * 时就会停，所以正常情况下读的仍是那几十条；只有碰上超长回合才会真往上读到 2000。
+ */
+const ENTRY_THIN_MAX_MESSAGES = 2000;
+const ENTRY_THIN_MIN_TURNS = 6;
+
+/** 把入口窗口的取数参数写进宿主请求体（就地修改并返回，调用方只关心副作用）。 */
+function entryWindowPayload(payload, limit) {
+  payload.maxMessages = ENTRY_THIN_MAX_MESSAGES;
+  payload.turnWindow = {
+    minMessages: Math.min(Math.max(limit, 1), ENTRY_THIN_MAX_MESSAGES),
+    minTurns: ENTRY_THIN_MIN_TURNS,
+  };
+  return payload;
+}
+
+module.exports = { entryWindowPayload, ENTRY_THIN_MAX_MESSAGES, ENTRY_THIN_MIN_TURNS };

package/lib/mobile/events.js

@@ -18,6 +18,8 @@
  */
 'use strict';
 
+const streamRegistry = require('./stream-registry.js');
+const { createFrameSealer } = require('./stream.js');
 const { listSignal: sharedListSignal } = require('../shared/list-signal.js');
 const { sessionSignal: sharedSessionSignal } = require('../shared/session-signal.js');
 const { desktopViewSignal: sharedDesktopViewSignal } = require('../shared/desktop-view-signal.js');
@@ -53,10 +55,13 @@ function logDeviceStream(message, error) {
  * 返回值与会话流一致：`ok:false` 该收尾，`shed:true` 这条被丢掉（调用方必须断流），
  * `needDrain:true` 写进去了但底下已经写不动。
  */
-function writeSse(res, payload, frame) {
+function writeSse(res, payload, frame, sealFrame) {
   return sharedWriteSse(res, payload, {
     frame,
     namespace: 'device',
+    // 协议 v2 的会话上这条流也逐帧封装：`App` 判定「这条会话是加密的」之后，收到一帧
+    // 明文就当畸形帧计数，连着十帧就把整条流判死、退回 15 秒轮询（2026-10-24 现场）。
+    sealFrame: typeof sealFrame === 'function' ? sealFrame : null,
     shedWhenBuffered: () => true,
   });
 }
@@ -133,17 +138,22 @@ function listRelevantPayload(rawPayload) {
  * the envelope only provides a stable event identity for future clients.
  */
 async function handleDeviceStream(ctx, req, res) {
+  // 协议 v2：与 /session/stream 一样逐帧封装，头必须在 writeHead 之前声明。
+  const sealFrame = createFrameSealer(req);
   try {
     res.writeHead(200, {
       'content-type': 'text/event-stream; charset=utf-8',
       'cache-control': 'no-cache',
       connection: 'keep-alive',
+      ...(sealFrame ? { 'x-dsh-proto': '2' } : {}),
     });
   } catch { return; }
 
   res.write(': connected\n\n');
   const ac = new AbortController();
-  req.on('close', () => ac.abort());
+  // 按设备登记这条流：吊销时宿主主动断它（§3.3）。设备级流同样是「开着就一直收」。
+  const untrack = streamRegistry.track(req.__dshRecord && req.__dshRecord.deviceId, res);
+  req.on('close', () => { untrack(); ac.abort(); });
   // 写坏掉的连接不该把宿主整条流拖住，也不该让 'error' 在 res 上无人接住而变成未捕获异常。
   // （守卫 on 的存在是为了那些只实现 writeHead/write/end 的最小假体。）
   if (typeof res.on === 'function') res.on('error', () => ac.abort());
@@ -154,7 +164,7 @@ async function handleDeviceStream(ctx, req, res) {
       type: 'device/event',
       version: 1,
       payload: devicePayload,
-    }, null);
+    }, null, sealFrame);
     if (!result.ok) return false;
     // shed 不是成功：不能继续读，否则这一帧代表的变更永远补不回来。
     if (result.shed) return false;
@@ -291,7 +301,7 @@ async function handleDeviceStream(ctx, req, res) {
         payload,
       };
       // Keep the existing device/event JSON envelope unchanged; SSE metadata is additive.
-      const sent = writeSse(res, envelope, frame);
+      const sent = writeSse(res, envelope, frame, sealFrame);
       if (sent.shed) { clientGone = true; break; }
       if (!sent.ok || sent.needDrain) { clientGone = true; break; }
       framesSent += 1;