@mrrisega/dsh-remote 0.7.12-beta.1 → 0.7.12-beta.2

package/clients/dsh-remote/test/bridge-http-abort.test.mjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * B2 取消死请求（2026-11-08）。
+ *
+ * 生产问题：手机放弃（nginx 499 / 切页 / 锁屏）后，普通大响应仍会被 bridge 读完、gzip 完、
+ * **继续灌进隧道**，占住数据队列队头把同设备后续请求堵在后面（2026-11-07 事故里 77 次 499
+ * 每次都这么放大，最坏让 0 字节请求陪跑 97.6s）。
+ *
+ * 修复两端配合：
+ *   · 中继：`res.on("close")` 时**普通响应也**发 `http-abort`（可 `DSH_ROUTER_ABORT_DEAD=0` 回滚）；
+ *   · 桥：`http-abort` → abort 上游 fetch + `sender.drop(id)` 丢掉隧道里还没发的分片。
+ *
+ * 本文件锁四条：
+ *   ① `drop(id)` 之后该响应的剩余分片不再发出，且**其余条目的相对顺序不变**（严格 FIFO 不破）；
+ *   ② 被取消的条目不会回调 `onFlushed`（不许拿"取消"当"发完"去记耗时）；
+ *   ③ `http-abort` 到桥 → 上游 fetch 被 abort、`drop` 被调用、**不回 502**、inflight 归零；
+ *   ④ `DSH_BRIDGE_ABORT_DEAD=0` / 非法值解析（纯函数）。
+ */
+import assert from "node:assert/strict";
+import http from "node:http";
+import { after, test } from "node:test";
+
+// ⚠️ 必须在 import dsh-bridge.mjs **之前**把上游指到一个本地假服务：
+//    UPSTREAM 是模块加载时读 env 的；测试 ③ 需要一个"永不回完 body"的上游，才能证明
+//    `http-abort` 真的中止了 fetch（而不是等 120s 超时）。
+const slowUpstream = http.createServer((req, res) => {
+  res.writeHead(200, { "content-type": "application/json" });
+  res.write('{"partial":'); // 不 end：模拟大响应正在产出的中途
+});
+await new Promise((r) => slowUpstream.listen(0, "127.0.0.1", r));
+process.env.DSH_BRIDGE_UPSTREAM = `http://127.0.0.1:${slowUpstream.address().port}`;
+after(() => {
+  try { slowUpstream.closeAllConnections?.(); } catch { /* ignore */ }
+  try { slowUpstream.close(); } catch { /* ignore */ }
+});
+
+const { abortDeadEnabled, makePrioritySender, __httpInflightForTest, handleFrame, handleHttpFrame } =
+  await import("../dsh-bridge.mjs");
+
+function fakeSocket() {
+  const frames = [];
+  let pending = 0;
+  return {
+    frames,
+    rawSend(s) { frames.push(s); pending += s.length; },
+    bufferedAmount: () => pending,
+    drain(bytes = Infinity) { pending = Math.max(0, pending - bytes); return pending; }
+  };
+}
+
+function makeScheduler() {
+  const queue = [];
+  return {
+    schedule: (fn) => queue.push(fn),
+    setTimer: (fn) => queue.push(fn),
+    tick() { const fn = queue.shift(); if (!fn) return false; fn(); return true; },
+    pending: () => queue.length
+  };
+}
+
+function newSender() {
+  const sock = fakeSocket();
+  const sched = makeScheduler();
+  const sender = makePrioritySender({
+    rawSend: sock.rawSend,
+    bufferedAmount: sock.bufferedAmount,
+    schedule: sched.schedule,
+    setTimer: sched.setTimer
+  });
+  return { sock, sched, sender };
+}
+
+test("B2①：drop(id) 丢掉剩余分片；其余条目顺序不变；不回调 onFlushed", () => {
+  const { sock, sched, sender } = newSender();
+  let flushedBig = 0;
+
+  // 一条 400KB 的大响应（多片）先入队，之后才入队一个小响应
+  sender.send({ id: "big", type: "http", body: "A".repeat(400 * 1024) }, {
+    id: "big",
+    onFlushed: () => { flushedBig += 1; }
+  });
+  sender.send({ id: "small", type: "http", body: "ok" }, { id: "small" });
+  // 让大帧只发出前几片就停手（模拟"隧道很慢"）
+  sched.tick();
+  const beforeDrop = sock.frames.length;
+
+  sender.drop("big");
+  // drop 之后：大帧剩余分片一片都不许再发
+  for (let i = 0; i < 5000 && sched.pending() > 0; i += 1) { sock.drain(0); sched.tick(); }
+  const after = sock.frames.slice(beforeDrop).map((s) => JSON.parse(s));
+  assert.ok(after.every((f) => f.__chunk === undefined), `取消后不得再发大帧分片：${JSON.stringify(after).slice(0, 200)}`);
+  const small = after.find((f) => f.id === "small");
+  assert.ok(small, "取消大帧后，后面排队的小响应必须被发出（队头被腾空）");
+  assert.equal(flushedBig, 0, "被取消的条目不得回调 onFlushed（否则会把取消记成发完）");
+});
+
+test("B2②：drop 只删指定 id，其它条目的相对顺序原样保留（FIFO 不破）", () => {
+  const { sock, sched, sender } = newSender();
+  sender.send({ id: "a", type: "http", body: "A".repeat(300 * 1024) }, { id: "a" });
+  sender.send({ id: "b", type: "http", body: "b1" }, { id: "b" });
+  sender.send({ id: "c", type: "http", body: "c1" }, { id: "c" });
+  sched.tick(); // 大帧发出第 1 片
+
+  sender.drop("a"); // 取消正在传的 a
+  for (let i = 0; i < 5000 && sched.pending() > 0; i += 1) { sock.drain(4 * 1024 * 1024); sched.tick(); }
+
+  const ids = sock.frames.map((s) => { const o = JSON.parse(s); return o.__chunk ? "__chunk" : o.id; });
+  const firstB = ids.indexOf("b");
+  const firstC = ids.indexOf("c");
+  assert.ok(firstB >= 0 && firstC >= 0, "b / c 都必须发出");
+  assert.ok(firstB < firstC, `b 必须仍在 c 之前（入队顺序不因取消而变）：${ids.join(",")}`);
+  // a 的条目被整条删除：不应有 a 的**整帧**
+  assert.ok(!ids.includes("a"), "被取消的 a 不得再出现");
+});
+
+test("B2③：http-abort 到桥 → abort 上游 fetch + drop(id) + 不回 502（端到端到 fetch）", async () => {
+  // 上游由文件顶部的 slowUpstream 提供（永不回完 body），才能验证 abort 真的生效
+  const sent = [];
+  const drops = [];
+  const sendFn = Object.assign(
+    (obj) => { sent.push(obj); return true; },
+    { drop: (id) => { drops.push(id); return 1; }, stats: () => ({ queued: 0, queuedBytes: 0, controlQueued: 0 }) }
+  );
+
+  const p = handleHttpFrame(sendFn, { id: "ab1", type: "http", method: "GET", path: "/api/slow" });
+  // 等到 controller 登记（= 已经进入 fetch 之前的那一步）
+  const t0 = Date.now();
+  while (__httpInflightForTest() < 1 && Date.now() - t0 < 3000) await new Promise((r) => setTimeout(r, 10));
+  assert.equal(__httpInflightForTest(), 1, "在飞请求必须被登记，才能被取消");
+
+  await handleFrame(sendFn, { id: "ab1", type: "http-abort" });
+  const t1 = Date.now();
+  await p; // 取消后必须快速 resolve，而不是等 120s 超时
+  assert.ok(Date.now() - t1 < 2000, "取消后必须立刻结束");
+  assert.deepEqual(drops, ["ab1"], "必须丢掉该 id 在隧道里还没发的分片");
+  assert.ok(!sent.some((f) => f.type === "http" && f.status === 502), `取消不得回 502 帧：${JSON.stringify(sent)}`);
+  assert.equal(__httpInflightForTest(), 0, "取消后 inflight 必须归零（不能泄漏 controller）");
+});
+
+test("B2④：abortDeadEnabled 解析（0/false/off 才关；非法值当开）", () => {
+  for (const v of ["0", "false", "OFF", "no", "disabled"]) assert.equal(abortDeadEnabled({ DSH_BRIDGE_ABORT_DEAD: v }), false, v);
+  for (const v of ["1", "true", "on", "yes", "anything"]) assert.equal(abortDeadEnabled({ DSH_BRIDGE_ABORT_DEAD: v }), true, v);
+});

package/clients/dsh-remote/test/bridge-slow-response.test.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * B0 观测（2026-11-08）：慢响应计时口径。
+ *
+ * 生产问题：首屏资源从 PC 出来只有 3–16KB/s，但原日志只有 "→ 200 (3200ms, 1700KB)"，
+ * 分不清慢在宿主首包 / 读体 / gzip / 注入 / **排队等隧道**（后者是本轮最要紧的一段）。
+ *
+ * 锁三条：
+ *   ① 发送器的 `onFlushed` 在整条数据帧**所有分片都 rawSend 完**之后才回调（否则计时会偏小）；
+ *   ② 慢响应行格式包含五段耗时、且**不把查询串写进日志**（与埋点/中继日志口径一致）；
+ *   ③ timings 用不可枚举属性挂回回包对象 —— `JSON.stringify(reply)` 不带它，隧道帧字节不变。
+ */
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+import { formatSlowResponse, makePrioritySender, slowRespLogOptions } from "../dsh-bridge.mjs";
+
+const BRIDGE_SRC = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "dsh-bridge.mjs");
+
+function fakeSocket() {
+  const frames = [];
+  let pending = 0;
+  return {
+    frames,
+    rawSend(s) { frames.push(s); pending += s.length; },
+    bufferedAmount: () => pending,
+    drain(bytes = Infinity) { pending = Math.max(0, pending - bytes); return pending; }
+  };
+}
+
+function makeScheduler() {
+  const queue = [];
+  return {
+    schedule: (fn) => queue.push(fn),
+    setTimer: (fn) => queue.push(fn),
+    tick() { const fn = queue.shift(); if (!fn) return false; fn(); return true; },
+    pending: () => queue.length
+  };
+}
+
+test("B0①：onFlushed 在**全部**分片发完后才回调（且只回调一次）", () => {
+  const sock = fakeSocket();
+  const sched = makeScheduler();
+  const sender = makePrioritySender({
+    rawSend: sock.rawSend,
+    bufferedAmount: sock.bufferedAmount,
+    schedule: sched.schedule,
+    setTimer: sched.setTimer
+  });
+
+  const big = { id: "r1", type: "http", body: "A".repeat(300 * 1024) };
+  const total = JSON.stringify(big).length;
+  let flushAt = -1;
+  let flushCount = 0;
+  sender.send(big, { id: "r1", onFlushed: () => { flushAt = sock.frames.length; flushCount += 1; } });
+  assert.ok(sock.frames.length >= 1, "第一片当场发出");
+  // 大帧不会当轮发完
+  for (let i = 0; i < 5000 && sched.pending() > 0; i += 1) { sock.drain(4 * 1024 * 1024); sched.tick(); }
+  assert.equal(flushCount, 1, "必须只回调一次");
+  const chunks = Math.ceil(total / (64 * 1024));
+  assert.equal(flushAt, chunks, `回调时所有分片都应已发出（回调于第 ${flushAt} 条，应为 ${chunks}）`);
+});
+
+test("B0②：慢响应行五段齐全、去查询串、队列厚度可见", () => {
+  const line = formatSlowResponse({
+    method: "GET",
+    path: "/plugins/??@a/x.js,@b/y.js&rev=deadbeef",
+    status: 200,
+    totalMs: 3200,
+    timings: { ttfbMs: 120, readMs: 80, injectMs: 0, gzipMs: 40 },
+    queueWaitMs: 2900,
+    queue: { queued: 3, queuedBytes: 2270000 },
+    outBytes: 1740800
+  });
+  assert.match(line, /^\[bridge\] 慢响应: GET \/plugins\/ /, "必须以固定前缀开头、路径去查询串");
+  assert.ok(!line.includes("rev="), `日志不得含查询串：${line}`);
+  assert.match(line, /总 3200ms/);
+  assert.match(line, /上游首包 120ms/);
+  assert.match(line, /读体 80ms/);
+  assert.match(line, /注入 0ms/);
+  assert.match(line, /gzip 40ms/);
+  assert.match(line, /入队→发完 2900ms/);
+  assert.match(line, /队列 3条\/2270000B/);
+  assert.match(line, /下行 1700KB/);
+});
+
+test("B0③：slowRespLogOptions 默认值与 env 解析（非法值回默认）", () => {
+  assert.deepEqual(slowRespLogOptions({}), { thresholdMs: 2000, windowMs: 3000 });
+  assert.deepEqual(slowRespLogOptions({ DSH_BRIDGE_SLOW_RESP_MS: "500", DSH_BRIDGE_SLOW_LOG_MS: "0" }), { thresholdMs: 500, windowMs: 0 });
+  assert.deepEqual(slowRespLogOptions({ DSH_BRIDGE_SLOW_RESP_MS: "abc" }), { thresholdMs: 2000, windowMs: 3000 });
+  assert.deepEqual(slowRespLogOptions({ DSH_BRIDGE_SLOW_RESP_MS: "-5" }), { thresholdMs: 2000, windowMs: 3000 });
+});
+
+test("B0④：timings 不可枚举 —— 不会混进隧道帧（协议字节不变）", () => {
+  // 源码契约：必须用 defineProperty(..., enumerable:false)；不允许把 timings 塞进可枚举字段
+  const src = fs.readFileSync(BRIDGE_SRC, "utf8");
+  assert.match(src, /Object\.defineProperty\(reply, "timings", \{ value: timings, enumerable: false \}\)/);
+  // 行为验证：不可枚举属性不会出现在 JSON（= 隧道帧的序列化方式）里
+  const reply = { status: 200, headers: {}, body: "AA==", bodyBase64: true };
+  Object.defineProperty(reply, "timings", { value: { ttfbMs: 1, readMs: 2, injectMs: 3, gzipMs: 4 }, enumerable: false });
+  const wire = JSON.stringify({ id: "r1", type: "http", ...reply });
+  assert.ok(!wire.includes("timings"), `隧道帧不得带 timings：${wire}`);
+  assert.ok(wire.includes('"body":"AA=="'));
+});

package/clients/dsh-remote/test/bridge-tunnel-receiver.test.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+/**
+ * 隧道入站分片重组（P0-1，2026-11-08）。
+ *
+ * 生产缺陷：`connectTunnel` 的 `ws.on("message")` 处理器里**每条消息**都新建一个
+ * `makeFrameReceiver()`。而 `__chunk` 的 n 片是 n 条独立 WS 消息 ⇒ 攒片状态（bufs）
+ * 随消息一起丢 ⇒ 跨消息分片永远拼不齐，中继发来的大帧（大请求体等）在桥侧被静默丢弃。
+ * 中继侧一直是**连接级**单实例（index.mjs 在 connection 回调里建一次）。
+ *
+ * 本文件锁三条：
+ *   ① 一个连接级 dispatcher 喂多条消息 → 能还原一条完整帧（跨消息重组）；
+ *   ② 多条分块序列交错到达 → 各自独立还原（状态是 Map，不是单槽）；
+ *   ③ 源码契约：`connectTunnel` 里只允许建一次接收器（且不得再出现 makeFrameReceiver()）。
+ */
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+import { createTunnelFrameDispatcher, makeFrameReceiver } from "../dsh-bridge.mjs";
+
+const BRIDGE_SRC = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "dsh-bridge.mjs");
+
+/** 把一条大帧按 chunkSize 切成 `__chunk` 消息（与 makePrioritySender.enqueueData 同款信封）。 */
+function splitFrame(obj, chunkSize, chunkId = "cx") {
+  const text = JSON.stringify(obj);
+  if (text.length <= chunkSize) return [text];
+  const n = Math.ceil(text.length / chunkSize);
+  const out = [];
+  for (let i = 0; i < n; i += 1) {
+    out.push(JSON.stringify({ __chunk: { id: chunkId, n, i, data: text.slice(i * chunkSize, (i + 1) * chunkSize) } }));
+  }
+  return out;
+}
+
+test("P0-1①：跨 WS 消息的分片，用**同一个**连接级 dispatcher 能完整重组", () => {
+  const got = [];
+  const dispatch = createTunnelFrameDispatcher((f) => got.push(f));
+
+  const big = { id: "r1", type: "http", method: "POST", path: "/api/upload", body: "A".repeat(5000), bodyBase64: true };
+  const parts = splitFrame(big, 1000);
+  assert.ok(parts.length >= 5, `应切成多片（实际 ${parts.length}）`);
+
+  // 一条消息一片地喂（生产就是这种情况：每片是一次独立 ws.send）
+  for (const p of parts) {
+    assert.equal(got.length, 0, "喂齐之前不应回调");
+    dispatch(p);
+  }
+  assert.equal(got.length, 1, "跨消息必须能还原成一帧");
+  assert.equal(got[0].id, "r1");
+  assert.equal(got[0].path, "/api/upload");
+  assert.equal(got[0].body.length, big.body.length, "重组后正文逐字节一致");
+  assert.equal(got[0].body, big.body);
+});
+
+test("P0-1②：两条分块序列交错到达，各自独立还原（状态是 Map 而非单槽）", () => {
+  const got = [];
+  const dispatch = createTunnelFrameDispatcher((f) => got.push(f));
+
+  const a = { id: "a", type: "http", body: "a".repeat(2500) };
+  const b = { id: "b", type: "http", body: "b".repeat(2500) };
+  const pa = splitFrame(a, 700, "ca");
+  const pb = splitFrame(b, 700, "cb");
+
+  const max = Math.max(pa.length, pb.length);
+  for (let i = 0; i < max; i += 1) {
+    if (pa[i]) dispatch(pa[i]);
+    if (pb[i]) dispatch(pb[i]);
+  }
+  assert.equal(got.length, 2, "两条序列都应还原");
+  const fa = got.find((f) => f.id === "a");
+  const fb = got.find((f) => f.id === "b");
+  assert.equal(fa.body, a.body);
+  assert.equal(fb.body, b.body);
+});
+
+test("P0-1③：未分片的普通帧直通（行为不变）", () => {
+  const got = [];
+  const dispatch = createTunnelFrameDispatcher((f) => got.push(f));
+  dispatch(JSON.stringify({ id: "w1", type: "ws-open", ok: true }));
+  assert.deepEqual(got, [{ id: "w1", type: "ws-open", ok: true }]);
+});
+
+test("P0-1④：非 JSON / 损坏分块不得抛（连接不能因为坏帧整个断掉）", () => {
+  const got = [];
+  const dispatch = createTunnelFrameDispatcher((f) => got.push(f));
+  dispatch("not-json{");
+  dispatch(JSON.stringify({ __chunk: { id: "bad", n: 2, i: 0, data: "{" } }));
+  assert.equal(got.length, 0);
+  dispatch(JSON.stringify({ id: "ok", type: "http-chunk" }));
+  assert.equal(got.length, 1, "坏帧之后仍要继续工作");
+});
+
+/** 从 `function foo(` 起始位置取出到匹配右花括号为止的函数体（朴素花括号计数，避开字符串里的括号够用）。 */
+function extractFunction(src, signature) {
+  const start = src.indexOf(signature);
+  assert.ok(start > 0, `必须能找到 ${signature}`);
+  const open = src.indexOf("{", start);
+  assert.ok(open > start, `${signature} 必须有大括号`);
+  let depth = 0;
+  for (let i = open; i < src.length; i += 1) {
+    const ch = src[i];
+    if (ch === "{") depth += 1;
+    else if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) return src.slice(start, i + 1);
+    }
+  }
+  throw new Error(`${signature} 花括号不闭合`);
+}
+
+test("P0-1⑤：源码契约 —— connectTunnel 里接收器只能建一次，且不得在 message 回调里 new", () => {
+  const src = fs.readFileSync(BRIDGE_SRC, "utf8");
+  const body = extractFunction(src, "function connectTunnel(token)");
+  // 只看代码：注释里会引用这个函数名（解释历史缺陷），不能算违规
+  const code = body.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+
+  assert.match(code, /createTunnelFrameDispatcher\(/, "必须用连接级 dispatcher");
+  assert.doesNotMatch(
+    code,
+    /makeFrameReceiver\s*\(/,
+    "connectTunnel 内不得直接 new makeFrameReceiver()（每条消息新建会让跨消息 __chunk 永远拼不齐 —— 2026-11-08 P0-1）"
+  );
+  // 且 dispatcher 只建一次（在 ws.on("message") 之前）
+  const messageHandler = body.indexOf('ws.on("message"');
+  assert.ok(messageHandler > 0, '必须找到 ws.on("message")');
+  assert.ok(
+    body.lastIndexOf("createTunnelFrameDispatcher(", messageHandler) > 0,
+    'dispatcher 必须在 ws.on("message") 之前创建（连接级单实例）'
+  );
+  // makeFrameReceiver 本身不能改变协议：仍是 (raw,onFrame) 形状，供 dispatcher/测试共用
+  const recv = makeFrameReceiver();
+  assert.equal(typeof recv, "function");
+});