dsh-mobile-plugin 0.1.88 → 0.1.89

package/lib/relay/lan-proxy.js

@@ -33,6 +33,12 @@ const WS_UPSTREAM_HANDSHAKE_MS = 10_000;
 // 不是「一轮推送有多大」：预览页面一次推几 MB 很正常，按 1MiB 判超限只会把正常的页面
 // 判成 502。
 const WS_UPSTREAM_PENDING_MAX_BYTES = 32 * 1024 * 1024;
+// 局域网直连允许同时活着的上游 SSE 条数。它兜的是**半开连接**：手机走了但 TCP 还没
+// 被拆掉（飞机模式、睡死、拔线都不会发 FIN），只有这种情况才需要一道闸。
+// 与中转路的同名上限（tunnel.js 的 16）刻意不是一个量级：那边所有设备共用一条隧道，
+// 设备多就得挤；这边每台设备各有自己的 TCP，实测 3 台设备正常十来条。所以这里留出
+// 成倍余量，只当失控闸——正常使用不该碰到它。
+const MAX_UPSTREAM_SSE_CONNECTIONS = 64;
 
 function createLanProxy(opts) {
   const {
@@ -51,10 +57,15 @@ function createLanProxy(opts) {
     onApprove = async () => ({ approved: false }),
     /** 读取隔离：本地镜像快照读取回调，命中时直接回（不再连主进程）。 */
     readSnapshot = () => null,
+    /** 上游 SSE 的失控闸，默认见 MAX_UPSTREAM_SSE_CONNECTIONS。 */
+    maxUpstreamSse = MAX_UPSTREAM_SSE_CONNECTIONS,
   } = opts;
 
   let server = null;
   let wss = null;
+  // 活着的上游请求计数（自检台账与失控闸消费）：见 proxyToUpstream 的拆除注释。
+  let upstreamOpen = 0;
+  let upstreamSseOpen = 0;
   // 实际监听的端口。首选端口被占时（见 lib/relay/port-allocator.cjs）会退到内核
   // 分配的空闲端口，这时对外必须报 `actualPort` 而不是 `lanPort`，否则状态接口和
   // 配对二维码里带的都是那个根本没在监听的死端口。
@@ -192,6 +203,18 @@ function createLanProxy(opts) {
     }
     // 保留手机端原始 Host（信任围栏按 Host 判定，配合桌面壳 --trusted-host 本机 IP）；缺省回退本地上游
     if (!headers.host) headers.host = `${upstreamHost}:${upstreamPort}`;
+    const isSse = String(req.headers.accept || '').toLowerCase().includes('text/event-stream');
+    if (isSse && upstreamSseOpen >= maxUpstreamSse) {
+      // 留一行日志：否则事后只看到手机端「连不上」，看不出是被这道闸挡的。
+      log(`上游 SSE 已达上限 ${maxUpstreamSse}，拒绝新流（手机侧会重连）`);
+      try {
+        res.writeHead(429, { 'content-type': 'text/plain; charset=utf-8', 'retry-after': '2' });
+        res.end('局域网直连的上游长流已达上限，请稍后重连\n');
+      } catch { /* 已关闭 */ }
+      return;
+    }
+    upstreamOpen += 1;
+    if (isSse) upstreamSseOpen += 1;
     const up = http.request(
       { hostname: upstreamHost, port: upstreamPort, method: req.method, path: req.url, headers },
       (ures) => {
@@ -203,6 +226,11 @@ function createLanProxy(opts) {
         ures.pipe(res);
       },
     );
+    // 计数只在这里退：ClientRequest 的 close 一定会来（正常收尾、报错、被 destroy 都算）。
+    up.on('close', () => {
+      upstreamOpen -= 1;
+      if (isSse) upstreamSseOpen -= 1;
+    });
     up.on('error', (err) => {
       log('proxy error:', err.message);
       try {
@@ -210,6 +238,22 @@ function createLanProxy(opts) {
         res.end(`upstream error: ${err.message}`);
       } catch { /* 已关闭 */ }
     });
+    /**
+     * 手机走了，必须把上游这条请求一起拆掉。
+     *
+     * 旧实现只挂了 `error`：手机断开之后上游请求还活着，宿主那边的响应就永远等不到
+     * `close`，于是 events 流与每条会话流的订阅**永不退订**——宿主继续往一条没人读的
+     * 连接上生成帧与正文。2026-10-19 实测：一台机器 12 条手机连接攒出 216 条上游长流，
+     * 宿主进程涨到 3.5～5G、CPU 30～40%，重启后回到 530M。同一个插件的中转路径有
+     * `httpCancel` 帧负责拆（tunnel.js），只有局域网这条路漏了。
+     *
+     * `res.writableEnded` 是判据：正常活完的响应结束时就已置位，不该再去动上游；
+     * 只有「客户端提前走」才会落到 false。
+     */
+    res.on('close', () => {
+      if (res.writableEnded) return;
+      try { up.destroy() } catch { /* 已断开 */ }
+    });
     req.pipe(up);
   }
 
@@ -565,7 +609,16 @@ function createLanProxy(opts) {
   // 对外只暴露「实际在监听的端口」。配置端口仍是 `lanPort`（那只是首选值）。
   const port = () => actualPort;
 
-  return { start, stop, port };
+  return {
+    start,
+    stop,
+    port,
+    /**
+     * 自检用：此刻活着的上游请求数，以及其中 SSE 的条数。
+     * 两个数都该跟着手机连接一起涨落；只涨不落就说明拆除那一环又断了。
+     */
+    stats: () => ({ upstreamOpen, sseOpen: upstreamSseOpen }),
+  };
 }
 
 module.exports = { createLanProxy };

package/lib/relay/tunnel.js

@@ -94,6 +94,14 @@ class RelayTunnel {
     return !!this.ws && this.ws.readyState === WebSocket.OPEN;
   }
 
+  /**
+   * 中转路上活着的上游 SSE 条数。自检台账（`/api/relay/status` 的 `selfCheck`）读它：
+   * 局域网那条路有同名上限，两条路放一起才看得出「上游长流是不是只涨不落」。
+   */
+  get upstreamSseCount() {
+    return this.sseClients.size;
+  }
+
   /**
    * 发送队列积压到上限时**只丢这一帧，不断开隧道**。
    *

package/lib/routes/control-plane.js

@@ -36,6 +36,9 @@ const readReceipt = require('../read-receipt.cjs');
 // 客户端半边的活体台账：两条绿点同步通道都是「单向轮询 + 无回执」，不记账就永远分不开
 // 「那半边根本没在跑」和「跑了但没清掉」（详见 lib/desktop-half-stats.cjs 的文件头）。
 const desktopHalf = require('../desktop-half-stats.cjs');
+// 内存自检台账：两个进程的内存、活着的流数、镜像缓存与凭据库规模。口径（「宿主进程」
+// 不等于「插件内存」）与各字段的来源写在 lib/mobile/self-check.cjs 的文件头。
+const { createSelfCheck } = require('../mobile/self-check.cjs');
 // 「查有没有新版」与「装新版」这两格都归插件自己：查直接问 npm 注册表，装在 profile 里跑
 // 它自己的包管理器（见 `../update-registry.cjs` / `../update-install.cjs`）。不再借道市场。
 const { checkForUpdate } = require('../update-registry.cjs');
@@ -233,11 +236,28 @@ function registerControlPlaneRoutes(deps) {
     // 插件 ctx。只给「桌面端说它读过了」那条路由用：它要清掉宿主侧的完成提醒。
     // 缺省 null 时那条路由降级为「只回 200、什么都不清」。
     ctx = null,
+    // 内存自检台账的取值器（`/api/relay/status` 的 `selfCheck` 字段）。
+    // `getSidecarSnapshot` 是 worker 的 `/status` 快照——侧车内存与中转路 SSE 数只有
+    // 这一条既有通道；`getLanProxyStats` 是局域网代理的 `stats()`，约定形状
+    // `() => ({ upstreamOpen, sseOpen })`。拿不到就报 null（`unavailable` 里说明原因），
+    // 不拿 0 顶替：0 是「一条流都没有」，与「不知道」是两件事。
+    getSidecarSnapshot = () => null,
+    getMirrorPush = () => null,
+    getMirrorPushFailures = () => null,
+    getLanProxyStats = () => null,
     // **外壳**暴露的换代服务（`dshMobilePluginRuntime`）。更新的机制住在外壳里，而这几条
     // 路由住在代里 —— 代被换掉之后服务还在，接口也就跟着活下来。
     // 缺省返回 null：`lib/impl.js` 单独挂载时（测试 / 老宿主）没有外壳，如实报不可用。
     getPluginRuntime = () => null,
   } = deps;
+  const selfCheck = createSelfCheck({
+    ctx,
+    credentials,
+    getSidecarSnapshot,
+    getMirrorPush,
+    getMirrorPushFailures,
+    getLanProxyStats,
+  });
   const webAccessWindow = createWebAccessWindow();
   const localOnly = createWebAccessLocalOnly({
     localOnly: baseLocalOnly,
@@ -327,7 +347,7 @@ function registerControlPlaneRoutes(deps) {
     const webAccess = body.enabled ? webAccessWindow.enable() : webAccessWindow.disable();
     return sendJson(res, 200, { ok: true, webAccess });
   }) });
-  registerRoute({ kind: 'exact', path: '/api/relay/status', handler: localOnly('GET', async (req, res) => sendJson(res, 200, { ...status(), panelUrl: panelUrlOf(req), webAccess: webAccessWindow.status(), ...mobileActivity() })) })
+  registerRoute({ kind: 'exact', path: '/api/relay/status', handler: localOnly('GET', async (req, res) => sendJson(res, 200, { ...status(), panelUrl: panelUrlOf(req), webAccess: webAccessWindow.status(), ...mobileActivity(), selfCheck: selfCheck.snapshot() })) })
   // 面板页本体：设置界面从客户端半边搬到这里，浏览器（或桌面端里的「打开配置页面」）
   // 直接打开它。三条地址吐的是同一份 HTML，分流在 React 侧（见 React/src/Root.tsx）：
   //   /api/relay/panel            看宿主记的「配没配过」，自己决定先走引导还是直接进主页

package/lib/shared/sse-write.js

@@ -0,0 +1,168 @@
+'use strict';
+
+/**
+ * SSE 写帧的唯一实现：单会话流（lib/mobile/stream.js）与设备级流（lib/mobile/events.js）
+ * 共用这一份。
+ *
+ * 为什么要合并：两条流曾经各有一份几乎相同的实现，而 2026-10-17 的宿主 OOM（堆快照里
+ * 17.6 万条 SSE 帧、466MB 挂在 `WriteWrap._chunks` 上，七十分钟涨到 3.9G 被杀）先修了
+ * 会话流那份，隔一轮才发现设备流那份还漏着 —— 同一个坑修两遍，就是因为实现有两份。
+ * 现在「这条连接上到底积压了多少字节」「软/硬水位怎么判」「SSE 记录长什么样」「稳定
+ * 事件 id 怎么算」「写不动时怎么等 drain」都只在这里，两条流只在调用点上声明自己的策略。
+ *
+ * 两条流刻意保留的差异（不是遗漏，改之前先看各自的理由）：
+ *  - 丢帧口径：会话流的软水位只丢**没有 seq** 的增量（`assistant/chunk` 是草稿，同一轮
+ *    收尾的 `assistant/message` 带完整正文、重连 `replaySince` 能补齐）；设备级流的帧
+ *    全是「有东西变了」的幂等信号，软水位一律丢，下一次变更或重连补发会再补上。
+ *    由调用方传 `shedWhenBuffered`。
+ *  - 写不动时：会话流 `await` 一次 drain（20s 超时再收尾）；设备级流直接收尾让客户端
+ *    重连 —— 它没有 Last-Event-ID 续传，但连上时会 `replayKnownSignals()` 补发当前状态，
+ *    所以「断开重连」是它的正常收敛路径。
+ *  - 填充：会话流每条记录补 2048 字节 SSE 注释（Android RN 的 XHR 会攒小 chunk，
+ *    不补就迟迟不触发 onprogress）；设备级流的帧很少、单帧也小，不补。
+ */
+
+const crypto = require('crypto');
+
+const SSE_RETRY_MS = 3000;
+
+/**
+ * 写缓冲的两道水位（字节）。
+ *
+ * `res.write()` 在客户端读得慢时返回 false，字节留在 Node 的写队列里。两道闸分开，因为
+ * 两种帧「丢了能不能补」不一样：软水位只丢可丢弃的帧（见上面丢帧口径），连接继续活着；
+ * 硬水位连不可丢的帧都放不下了，就收尾让客户端重连补齐 —— 断流可恢复，堆内存不会。
+ */
+const SSE_SHED_BUFFERED_BYTES = 4 * 1024 * 1024;
+const SSE_CLOSE_BUFFERED_BYTES = 16 * 1024 * 1024;
+
+/**
+ * 等一次 `drain` 的上限。超过这么久还没排空，说明对面不是慢、是真的不读了（手机切
+ * 后台、中转卡住），继续等只是把这条连接挂在那里，不如收尾让客户端重连。
+ */
+const SSE_DRAIN_TIMEOUT_MS = 20_000;
+
+/** 默认丢帧口径：没有 seq 的帧可以丢，有 seq 的不能（丢了不回放就在手机上留个洞）。 */
+const shedWithoutSeq = (payload) => !Number.isFinite(payload && payload.seq);
+
+/** 每条记录后面补的 SSE 注释（客户端忽略内容，只用来把小 chunk 撑过 RN 的缓冲阈值）。 */
+function ssePadding(bytes) {
+  const size = Number(bytes) > 0 ? Math.floor(Number(bytes)) : 0;
+  return size > 0 ? `: ${' '.repeat(size)}` : '';
+}
+
+/**
+ * 这条连接上真正「还没发出去」的字节数。
+ *
+ * 只看 `res.writableLength` 是错的：它只算响应对象自己那一层，真正的积压在底下的套接字
+ * 写队列里（堆快照里那些 `{chunk, encoding, callback}`）。2026-10-18 复测证实：只看前者
+ * 时闸门从不触发，内存照涨。所以顺着 socket 一起看，取较大值。
+ */
+function bufferedBytesOf(res) {
+  const own = Number(res.writableLength) || 0;
+  const socket = res.socket || res.connection;
+  const queued = socket ? Number(socket.writableLength) || 0 : 0;
+  return Math.max(own, queued);
+}
+
+/**
+ * SSE 记录的 `id:` 字段：客户端断线重连时用它续传，所以必须对同一帧稳定。
+ *
+ * `namespace` 只参与「认不出身份时按内容摘要兜底」的那一支：两条流的兜底前缀不同
+ * （会话流用 `session`、设备级流用 `device`），改它会改客户端看到的 id 形状。
+ */
+function stableEventId(payload, frame, namespace = 'session') {
+  const source = payload && payload.type === 'session/event' ? payload : frame && frame.payload;
+  if (source && typeof source === 'object') {
+    if (source.type === 'session/event' && source.sessionId && source.event && Number.isFinite(source.event.seq)) {
+      return `${source.sessionId}:${source.event.seq}`;
+    }
+  }
+  if (payload && typeof payload === 'object') {
+    for (const key of ['eventId', 'rpcId', 'id', 'approvalId']) {
+      if (typeof payload[key] === 'string' && payload[key]) return payload[key];
+    }
+    const sessionId = typeof payload.sessionId === 'string' ? payload.sessionId : namespace;
+    const digest = crypto.createHash('sha256').update(JSON.stringify(payload)).digest('hex').slice(0, 24);
+    return `${sessionId}:${payload.type || 'event'}:${digest}`;
+  }
+  return frame && typeof frame.rpcId === 'string' && frame.rpcId ? frame.rpcId : undefined;
+}
+
+/**
+ * 写一条 SSE 记录。
+ *
+ * @param {object} res 响应对象（真实 http.ServerResponse，或测试里的最小假体）
+ * @param {object} payload 要写进 `data:` 的内容
+ * @param {object} [options]
+ * @param {object} [options.frame] 宿主 mux 帧，只用于算稳定 id
+ * @param {string} [options.namespace='session'] 兜底 id 的前缀
+ * @param {string} [options.padding=''] 每条记录后补的 SSE 注释行（见 ssePadding）
+ * @param {number} [options.retryMs=SSE_RETRY_MS] SSE 重连间隔
+ * @param {(payload: object) => boolean} [options.shedWhenBuffered] 超过软水位时这一帧能不能丢
+ * @returns {{ok: boolean, shed?: boolean, needDrain?: boolean}}
+ *   `ok:false` → 这条流该收尾（客户端走了，或积压超过硬水位）；
+ *   `shed:true` → 这条帧被丢掉、连接还活着；
+ *   `needDrain:true` → 写成功了，但底下已经写不动，调用方要先 await 一次 drain 再继续。
+ */
+function writeSse(res, payload, options = {}) {
+  const {
+    frame = null,
+    namespace = 'session',
+    padding = '',
+    retryMs = SSE_RETRY_MS,
+    shedWhenBuffered = shedWithoutSeq,
+  } = options;
+  const buffered = bufferedBytesOf(res);
+  if (buffered > SSE_CLOSE_BUFFERED_BYTES) return { ok: false };
+  if (buffered > SSE_SHED_BUFFERED_BYTES && shedWhenBuffered(payload)) return { ok: true, shed: true };
+  const id = stableEventId(payload, frame, namespace);
+  const fields = [`retry: ${retryMs}`];
+  if (id) fields.push(`id: ${id}`);
+  fields.push(`data: ${JSON.stringify(payload)}`);
+  if (padding) fields.push(padding);
+  fields.push('', '');
+  try {
+    // `write()` 返回 false 才是背压的正信号：数据已经堆到高水位，继续写只会把内存
+    // 堆起来。把它当成功吞掉，正是那次 4GB OOM 的直接原因。
+    const accepted = res.write(`${fields.join('\n')}\n`);
+    return { ok: true, needDrain: accepted === false };
+  } catch { return { ok: false }; }
+}
+
+/**
+ * 等底层把缓冲吐出去（`drain`）。背压的正解：写不动就停手，而不是继续塞。
+ *
+ * @returns {Promise<boolean>} 真的 drain 了 → true；超时或流被中断 → false（该收尾）。
+ */
+function waitForDrain(res, signal, timeoutMs = SSE_DRAIN_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    if (signal && signal.aborted) return resolve(false);
+    let done = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      if (typeof res.off === 'function') res.off('drain', onDrain);
+      if (signal && typeof signal.removeEventListener === 'function') signal.removeEventListener('abort', onAbort);
+    };
+    const finish = (value) => { if (done) return; done = true; cleanup(); resolve(value); };
+    const onDrain = () => finish(true);
+    const onAbort = () => finish(false);
+    const timer = setTimeout(() => finish(false), timeoutMs);
+    if (typeof timer.unref === 'function') timer.unref();
+    if (typeof res.once === 'function') res.once('drain', onDrain);
+    if (signal && typeof signal.addEventListener === 'function') signal.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+module.exports = {
+  SSE_RETRY_MS,
+  SSE_SHED_BUFFERED_BYTES,
+  SSE_CLOSE_BUFFERED_BYTES,
+  SSE_DRAIN_TIMEOUT_MS,
+  ssePadding,
+  bufferedBytesOf,
+  stableEventId,
+  writeSse,
+  waitForDrain,
+  shedWithoutSeq,
+};

package/lib/sidecar-facade-worker.cjs

@@ -331,7 +331,14 @@ async function configure(next) {
   return status()
 }
 function status() {
-  return { ok: true, sidecar: true, enabled: Boolean(config.enabled), relayUrl: config.relayUrl || '', instanceId: config.instanceId, name: config.name, localPort: config.upstreamPort, tunnel: { state: tunnelState, error: tunnelError }, lan: { enabled: Boolean(config.lanEnabled), port: lanUrlPort(), requestedPort: config.lanPort, state: lanState, error: lanError } }
+  // 自检台账（`/api/relay/status` 的 `selfCheck`）要的三样东西只有 worker 这边量得到：
+  //   - `process.memoryUsage`：侧车是**另一个进程**，这是插件唯一能直接量到的自有内存；
+  //   - `streams.lan`：局域网代理里此刻活着的上游流（手机半开连接攒起来时，只有它只涨不落）；
+  //   - `streams.relaySseOpen`：中转路上活着的上游 SSE 条数。
+  // 量不到的一律报 null、不拿 0 顶替：0 是「一条都没有」，与「不知道」是两件事。
+  const lanStreams = lan && typeof lan.stats === 'function' ? lan.stats() : null
+  const relaySseOpen = tunnel ? (typeof tunnel.upstreamSseCount === 'number' ? tunnel.upstreamSseCount : null) : 0
+  return { ok: true, sidecar: true, enabled: Boolean(config.enabled), relayUrl: config.relayUrl || '', instanceId: config.instanceId, name: config.name, localPort: config.upstreamPort, tunnel: { state: tunnelState, error: tunnelError }, lan: { enabled: Boolean(config.lanEnabled), port: lanUrlPort(), requestedPort: config.lanPort, state: lanState, error: lanError }, process: { memoryUsage: process.memoryUsage() }, streams: { lan: lanStreams, relaySseOpen } }
 }
 const server = http.createServer(async (req, res) => {
   try {

package/package.json

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