@mrrisega/dsh-remote 0.7.5-beta.1 → 0.7.6-beta.1

package/clients/dsh-remote/test/bridge-heartbeat-adaptive.test.mjs

@@ -1,110 +0,0 @@
-#!/usr/bin/env node
-/**
- * 心跳自适应回归（2026-10-23）。
- *
- * 生产事故（手机频繁断线主因链 #3）：
- *   固定 20s 心跳 + 固定"丢 2 个 pong 就重连"。DSH 主线程被大任务/大响应占住时，pong 在
- *   socket 事件里排不上队 → 连续两拍判死 → 重建隧道 → 手机侧全部在途请求断开、页面重连。
- *   全站 13706 次/天 bridge 断开里有一大批是这么来的。
- *
- * 本文件锁「纯函数」契约（真机/集成行为由 bridge 日志与 test:bridge 全量保证）：
- *   ① 健康链路完全保留旧契约（丢 2 拍才断）；
- *   ② 本机事件循环延迟高 / RTT 慢 / 已在中断中 → 判定窗口放宽；
- *   ③ 放宽有上限（默认 4 拍 / 环境变量可调），不会退化成永不重连；
- *   ④ DSH_BRIDGE_HEARTBEAT_ADAPT=0 可退回旧契约。
- */
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  HEARTBEAT_LAG_BUSY_MS,
-  HEARTBEAT_MAX_MISSED_CAP_DEFAULT,
-  HEARTBEAT_MAX_MISSED_PONGS,
-  HEARTBEAT_RTT_SLOW_MS,
-  TUNNEL_HEARTBEAT_DEFAULT_MS,
-  __setEventLoopLagForTest,
-  adaptiveHeartbeat,
-  currentEventLoopLagMs,
-  heartbeatStep
-} from "../dsh-bridge.mjs";
-
-const BASE = TUNNEL_HEARTBEAT_DEFAULT_MS;
-
-test("① 健康链路 = 旧契约：收到 pong 就归零，连续 2 拍没 pong 才断", () => {
-  const pong = adaptiveHeartbeat({ pongReceived: true, missedPongs: 5, rttMs: 40, eventLoopLagMs: 1 });
-  assert.equal(pong.missedPongs, 0);
-  assert.equal(pong.terminate, false);
-  assert.equal(pong.intervalMs, BASE, "健康链路 ping 间隔不变");
-  assert.equal(pong.maxMissed, HEARTBEAT_MAX_MISSED_PONGS);
-
-  const one = adaptiveHeartbeat({ pongReceived: false, missedPongs: 0, rttMs: 40, eventLoopLagMs: 1 });
-  assert.equal(one.missedPongs, 1);
-  assert.equal(one.terminate, false, "丢 1 拍不断（旧行为是丢 1 就断）");
-
-  const two = adaptiveHeartbeat({ pongReceived: false, missedPongs: 1, rttMs: 40, eventLoopLagMs: 1 });
-  assert.equal(two.missedPongs, 2);
-  assert.equal(two.terminate, true, "健康链路下连续 2 拍没 pong 仍按旧契约判死");
-
-  // 与旧纯函数 heartbeatStep 在健康链路下结论一致
-  for (const missed of [0, 1, 2, 3]) {
-    const a = adaptiveHeartbeat({ pongReceived: false, missedPongs: missed, rttMs: 40, eventLoopLagMs: 0 });
-    const b = heartbeatStep({ pongReceived: false, missedPongs: missed });
-    assert.equal(a.terminate, b.terminate, `健康链路 missed=${missed} 的判定必须与旧契约一致`);
-  }
-});
-
-test("② 本机繁忙（事件循环延迟 ≥500ms）→ 多给一拍，瞬时卡顿不再判死", () => {
-  const plan = adaptiveHeartbeat({ pongReceived: false, missedPongs: 0, rttMs: 40, eventLoopLagMs: HEARTBEAT_LAG_BUSY_MS });
-  assert.equal(plan.maxMissed, HEARTBEAT_MAX_MISSED_PONGS + 1);
-  assert.ok(plan.reasons.includes("event_loop_busy"));
-  assert.equal(plan.terminate, false);
-  // 第 2 拍仍不断（这正是生产里 DSH 主线程卡 3~5 秒的场景）
-  const second = adaptiveHeartbeat({ pongReceived: false, missedPongs: 1, rttMs: 40, eventLoopLagMs: HEARTBEAT_LAG_BUSY_MS });
-  assert.equal(second.terminate, false, "繁忙时第 2 拍不得判死");
-  // 第 3 拍才断
-  const third = adaptiveHeartbeat({ pongReceived: false, missedPongs: 2, rttMs: 40, eventLoopLagMs: HEARTBEAT_LAG_BUSY_MS });
-  assert.equal(third.terminate, true);
-});
-
-test("③ 慢链路（RTT ≥1s）→ 间隔拉长 + 多给一拍；两者叠加有上限", () => {
-  const slow = adaptiveHeartbeat({ pongReceived: false, missedPongs: 0, rttMs: HEARTBEAT_RTT_SLOW_MS, eventLoopLagMs: 0 });
-  assert.ok(slow.maxMissed > HEARTBEAT_MAX_MISSED_PONGS);
-  assert.ok(slow.intervalMs > BASE, "慢链路 ping 间隔应拉长（减少额外负载）");
-  assert.ok(slow.intervalMs <= 60_000);
-  assert.ok(slow.reasons.includes("rtt_slow"));
-
-  // 繁忙 + 慢链路 + 已在中断中 → 上限封顶，不会无限放宽
-  const worst = adaptiveHeartbeat({
-    pongReceived: false,
-    missedPongs: 1,
-    rttMs: 5000,
-    eventLoopLagMs: 3000,
-    maxMissedCap: HEARTBEAT_MAX_MISSED_CAP_DEFAULT
-  });
-  assert.equal(worst.maxMissed, HEARTBEAT_MAX_MISSED_CAP_DEFAULT);
-  assert.equal(worst.terminate, false);
-  const capped = adaptiveHeartbeat({ pongReceived: false, missedPongs: 3, rttMs: 5000, eventLoopLagMs: 3000 });
-  assert.equal(capped.maxMissed, HEARTBEAT_MAX_MISSED_CAP_DEFAULT);
-  assert.equal(capped.terminate, true, "到了上限那一拍必须判死（不能永不重连）");
-});
-
-test("④ DSH_BRIDGE_HEARTBEAT_ADAPT=0 等价语义：完全退回固定窗口", () => {
-  const plan = adaptiveHeartbeat({
-    pongReceived: false,
-    missedPongs: 1,
-    rttMs: 5000,
-    eventLoopLagMs: 3000,
-    adaptive: false
-  });
-  assert.equal(plan.maxMissed, HEARTBEAT_MAX_MISSED_PONGS);
-  assert.equal(plan.intervalMs, BASE);
-  assert.equal(plan.terminate, true, "退回旧契约：第 2 拍即判死");
-});
-
-test("⑤ 事件循环延迟探针（测试钩子）", () => {
-  assert.equal(currentEventLoopLagMs(), 0);
-  __setEventLoopLagForTest(800);
-  assert.equal(currentEventLoopLagMs(), 800);
-  __setEventLoopLagForTest(-5);
-  assert.equal(currentEventLoopLagMs(), 0);
-});

package/clients/dsh-remote/test/bridge-ws-open-fast-ack.test.mjs

@@ -1,213 +0,0 @@
-#!/usr/bin/env node
-/**
- * ws-open 快速应答 / 上游建立期间消息不丢 / 上游失败用 ws-close 收尾（2026-10-23）。
- *
- * 旧契约：收到 ws-open → 连上游 WebSocket → **等上游 open** 才回 ok。
- *   上游连不上（桌面端换端口 / 宿主重启）时，手机要等 router 的 20s 超时；
- *   bridge 发送队列被大响应占住时（见 bridge-control-priority），连"回 ok"都排不上。
- *
- * 新契约（本文件锁住）：
- *   ① 校验通过立刻回 `{ok:true, fast:true}`（同步、<100ms），再连上游；
- *   ② 上游建立期间手机发来的 ws-msg 进 pending 队列，open 后按序补发（不丢 mux 首帧）；
- *   ③ 上游最终失败 → 回 `ws-close`(1011, retryable) 而不是干等 20s（升级早已 ack）；
- *   ④ E2EE 语义不变：带 &e2ee= 的流先校验会话；未知/未验证 → 1008 +
- *      `retryable:true,action:"rehandshake"`（手机可自动重握手，不用让用户重新解锁）。
- */
-import assert from "node:assert/strict";
-import http from "node:http";
-import { mkdtempSync, rmSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-import { setTimeout as delay } from "node:timers/promises";
-
-import { WebSocketServer } from "ws";
-
-// ── 上游假 dsh web：三种升级行为 ───────────────────────────────────────────────
-const upstream = http.createServer((req, res) => { res.writeHead(404); res.end(); });
-const wss = new WebSocketServer({ noServer: true });
-wss.on("connection", (ws) => {
-  ws.on("message", (data, isBinary) => {
-    try { ws.send(data, { binary: isBinary }); } catch { /* 手机侧已断 */ }
-  });
-});
-let upPort = 0;
-await new Promise((resolve) => {
-  upstream.listen(0, "127.0.0.1", () => {
-    upPort = upstream.address().port;
-    resolve();
-  });
-});
-upstream.on("upgrade", (req, socket, head) => {
-  let pathname = "";
-  try { pathname = new URL(req.url || "/", "http://x").pathname; } catch { pathname = ""; }
-  if (pathname === "/ws-slow") {
-    // 上游建立要 400ms：足够断言"ok 已经先回来了"
-    setTimeout(() => {
-      try { wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req)); } catch { /* 手机已断 */ }
-    }, 400);
-    return;
-  }
-  if (pathname === "/ws-reject") {
-    try { socket.destroy(); } catch { /* 忽略 */ }
-    return;
-  }
-  try { wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req)); } catch { /* 忽略 */ }
-});
-
-// ── 环境必须在 import dsh-bridge 之前定好（模块级常量在 import 时求值）────────────
-const tmpDir = mkdtempSync(path.join(os.tmpdir(), "dsh-wsopen-"));
-process.env.DSH_BRIDGE_CONFIG = path.join(tmpDir, ".dsh-config.json");
-process.env.DSH_BRIDGE_UPSTREAM = `http://127.0.0.1:${upPort}`;
-process.env.DSH_BRIDGE_TUNNEL_URL = "ws://127.0.0.1:1"; // 本用例不连隧道
-const bridge = await import("../dsh-bridge.mjs");
-const {
-  __setE2eeForTest,
-  __wsSessionState,
-  handleWsClose,
-  handleWsMessage,
-  handleWsOpen
-} = bridge;
-const e2eeMod = await import("../e2ee-client.mjs");
-
-test.after(() => {
-  try { wss.close(); } catch { /* 忽略 */ }
-  try { upstream.close(); } catch { /* 忽略 */ }
-  try { rmSync(tmpDir, { recursive: true, force: true }); } catch { /* 忽略 */ }
-});
-
-/** 记录 bridge → router 的帧（等价于隧道 send）。 */
-function spy() {
-  const frames = [];
-  const send = (obj) => {
-    frames.push({ ...obj, __at: Date.now() });
-    return true;
-  };
-  return { frames, send };
-}
-
-async function waitFor(label, pred, timeoutMs = 4000) {
-  const deadline = Date.now() + timeoutMs;
-  for (;;) {
-    const v = pred();
-    if (v) return v;
-    if (Date.now() > deadline) throw new Error(`等待超时：${label}`);
-    await delay(10);
-  }
-}
-
-test("① 先把 ok 回给手机（<100ms），再连上游；ok 不等于上游已建立", async () => {
-  const { frames, send } = spy();
-  const t0 = Date.now();
-  await handleWsOpen(send, { id: "fast1", type: "ws-open", path: "/ws-slow", headers: {} });
-  const elapsed = Date.now() - t0;
-  assert.ok(elapsed < 100, `ok 必须立刻回（实测 ${elapsed}ms）`);
-  assert.equal(frames.length, 1, "此刻只有 ws-open 回包，没有上游消息");
-  assert.equal(frames[0].ok, true);
-  assert.equal(frames[0].fast, true, "回包应带 fast:true（可观测：这是快速应答）");
-  // 上游还没建立（400ms 后才 open）
-  await delay(100);
-  assert.equal(__wsSessionState("fast1").opened, false, "100ms 时上游仍未建立");
-  await waitFor("上游 open", () => __wsSessionState("fast1")?.opened === true);
-  handleWsClose(send, { id: "fast1", code: 1000 });
-});
-
-test("② 上游建立期间手机发来的 ws-msg 不丢：排队 → open 后按序补发", async () => {
-  const { frames, send } = spy();
-  await handleWsOpen(send, { id: "fast2", type: "ws-open", path: "/ws-slow", headers: {} });
-  assert.equal(frames[0].ok, true);
-  // 手机拿到 ok 后立刻发（真实 mux 首帧就是这样）：此时上游还没 open
-  handleWsMessage(send, { id: "fast2", data: "first-frame", binary: false });
-  handleWsMessage(send, { id: "fast2", data: "second-frame", binary: false });
-  assert.equal(__wsSessionState("fast2").pending, 2, "两条消息应排队等上游");
-  // 上游 open 后：消息被补发 → echo 回来（顺序必须与发出顺序一致）
-  await waitFor("两条 echo", () => frames.filter((f) => f.type === "ws-msg").length >= 2, 5000);
-  const echoed = frames.filter((f) => f.type === "ws-msg").map((f) => String(f.data));
-  assert.deepEqual(echoed, ["first-frame", "second-frame"], "补发顺序必须与手机发出顺序一致");
-  handleWsClose(send, { id: "fast2", code: 1000 });
-});
-
-test("③ 上游建立失败 → ws-close(1011, retryable)，不再让手机干等 20s", async () => {
-  const { frames, send } = spy();
-  await handleWsOpen(send, { id: "fast3", type: "ws-open", path: "/ws-reject", headers: {} });
-  assert.equal(frames[0].ok, true, "先快速 ok");
-  const close = await waitFor("失败收尾帧", () => frames.find((f) => f.type === "ws-close"), 4000);
-  assert.equal(close.code, 1011);
-  assert.equal(close.retryable, true);
-  assert.match(String(close.reason || ""), /upstream_ws_open_failed/);
-  assert.equal(__wsSessionState("fast3"), null, "失败后会话表应清掉");
-});
-
-test("④ 非法路径仍同步拒绝(400)，不做快速 ok", async () => {
-  const { frames, send } = spy();
-  await handleWsOpen(send, { id: "bad1", type: "ws-open", path: "//evil.example/x", headers: {} });
-  assert.equal(frames.length, 1);
-  assert.equal(frames[0].ok, false);
-  assert.equal(frames[0].code, 400);
-});
-
-test("⑤ E2EE：未知会话 → 1008 + action=rehandshake（手机可自动重握手）", async () => {
-  const mk = Buffer.alloc(32, 7);
-  const svc = new e2eeMod.E2eeService({ enabled: true, mk, profile: "pbkdf2-sha256-600k", salt: "salt-abc", epoch: 0 });
-  __setE2eeForTest(svc);
-  try {
-    const { frames, send } = spy();
-    const sessId = e2eeMod.newSessId();
-    await handleWsOpen(send, {
-      id: "e2ee-locked",
-      type: "ws-open",
-      path: `/ws-echo?e2ee=${sessId}&w=0123456789abcdef`,
-      headers: {}
-    });
-    assert.equal(frames.length, 1);
-    assert.equal(frames[0].ok, false);
-    assert.equal(frames[0].code, 1008);
-    assert.equal(frames[0].retryable, true, "★ 必须显式告诉手机这是可自动重试的");
-    assert.equal(frames[0].action, "rehandshake", "★ 让手机自动重握手，而不是弹「请重新解锁」");
-    assert.match(String(frames[0].reason || ""), /e2ee_session_locked/);
-  } finally {
-    __setE2eeForTest(new e2eeMod.E2eeService({ enabled: false }));
-  }
-});
-
-test("⑥ E2EE 语义保持：已验证会话 → 快速 ok；加密消息解封→上游 echo→重新封装一致", async () => {
-  const mk = Buffer.alloc(32, 7);
-  const salt = "salt-abc";
-  const profile = "pbkdf2-sha256-600k";
-  const svc = new e2eeMod.E2eeService({ enabled: true, mk, profile, salt, epoch: 0 });
-  __setE2eeForTest(svc);
-  try {
-    // 跑 §5.2 握手（与生产同一条路径，只是"手机"在我们进程里）
-    const sessId = e2eeMod.newSessId();
-    const a = e2eeMod.randomB64(32);
-    const { session, ack } = svc.handleHello({ v: 2, type: "e2ee-hello", role: "phone", s: sessId, a: a, salt, profile });
-    const { shk, saltH } = e2eeMod.deriveShk(mk, a, ack.b);
-    const client = new e2eeMod.E2eeSession({ sessId, shk, saltH, profile, epoch: 0 });
-    const probe = client.seal({ kind: "ctrl", dir: "p2b", counter: 0, data: JSON.stringify({ p: "dsh-e2ee-probe-v1", t: 1, c: 0 }) });
-    svc.handleProbe(sessId, probe);
-    assert.equal(session.verified, true);
-
-    const w = "0123456789abcdef";
-    const wsLabel = `/ws-echo?w=${w}`;
-    const { frames, send } = spy();
-    await handleWsOpen(send, {
-      id: "e2ee-ok",
-      type: "ws-open",
-      path: `/ws-echo?e2ee=${sessId}&w=${w}`,
-      headers: {}
-    });
-    assert.equal(frames[0].ok, true);
-    assert.equal(frames[0].fast, true);
-    await waitFor("上游 open", () => __wsSessionState("e2ee-ok")?.opened === true);
-
-    const envP2b = client.seal({ kind: "w", dir: "p2b", counter: 0, data: "ping-加密-你好", wsLabel });
-    handleWsMessage(send, { id: "e2ee-ok", data: JSON.stringify(envP2b), binary: false });
-    const back = await waitFor("b2p 信封", () => frames.find((f) => f.type === "ws-msg" && String(f.data).includes('"k":"w"')), 5000);
-    const envB2p = JSON.parse(String(back.data));
-    const opened = client.open({ kind: "w", dir: "b2p", env: envB2p, counter: envB2p.c, wsLabel });
-    assert.equal(opened.data.toString("utf8"), "ping-加密-你好", "端到端加解密后逐字节一致");
-    handleWsClose(send, { id: "e2ee-ok", code: 1000 });
-  } finally {
-    __setE2eeForTest(new e2eeMod.E2eeService({ enabled: false }));
-  }
-});

package/clients/dsh-remote/test/e2ee-session-store.test.mjs

@@ -1,254 +0,0 @@
-#!/usr/bin/env node
-/**
- * E2EE 会话库（加密落盘 / 重启恢复 / 失效路径）回归（2026-10-23）。
- *
- * 生产事故（手机反复撞死票，主因链 #2）：
- *   e2ee-client.mjs 的 sessions 只是内存 Map（24h 滑动 TTL）。bridge 重启/崩一次，
- *   手机端保存的 sessId 就全成死票：HTTP 502 unknown_session、数据 WS 1008
- *   e2ee_session_locked，用户必须回设备列表重新解锁（实测某设备 3964 次）。
- *
- * 方案（本文件锁住）：
- *   ① 会话材料用 MK 派生的 storeKey 做 AES-256-GCM 加密后落 relay 数据目录
- *      `.e2ee-sessions.enc`（0600、原子写）；文件里**没有** MK/SHK 明文/密码；
- *   ② bridge 重启后恢复会话（含 verified 与 ctrl 防重放计数），手机旧票继续可用；
- *   ③ 解不开（改密/MK 变）/文件损坏/参数变化 → 丢弃文件并清空内存，返回 discarded 原因
- *      （上层据此给手机 retryable=rehandshake 信号，而不是让手机反复撞）；
- *   ④ 24h 滑动 TTL 仍生效：过期会话不恢复。
- */
-import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-
-import {
-  E2eeService,
-  E2eeSession,
-  SESSION_STORE_FILE,
-  SESSION_STORE_VERSION,
-  SESSION_TTL_MS,
-  clearSessionStore,
-  decryptSessionStore,
-  deriveSessionStoreKey,
-  deriveShk,
-  loadSessionStore,
-  newSessId,
-  randomB64,
-  saveSessionStore,
-  sessionStorePath
-} from "../e2ee-client.mjs";
-
-const DIRS = [];
-function tmpDir() {
-  const d = mkdtempSync(path.join(os.tmpdir(), "dsh-e2ee-store-"));
-  DIRS.push(d);
-  return d;
-}
-test.after(() => {
-  for (const d of DIRS) { try { rmSync(d, { recursive: true, force: true }); } catch { /* 忽略 */ } }
-});
-
-const MK = Buffer.alloc(32, 9);
-const SALT = "salt-store-test";
-const PROFILE = "pbkdf2-sha256-600k";
-const mkSvc = () => new E2eeService({ enabled: true, mk: MK, profile: PROFILE, salt: SALT, epoch: 1 });
-
-/** 建一个"已解锁且探测通过"的会话（手机侧也留一份，便于断言加解密仍可用）。 */
-function unlock(svc) {
-  const sessId = newSessId();
-  const a = randomB64(32);
-  const { session, ack } = svc.handleHello({ v: 2, type: "e2ee-hello", role: "phone", s: sessId, a: a, salt: SALT, profile: PROFILE });
-  const { shk, saltH } = deriveShk(MK, a, ack.b);
-  const client = new E2eeSession({ sessId, shk, saltH, profile: PROFILE, epoch: 1 });
-  const probe = client.seal({ kind: "ctrl", dir: "p2b", counter: 0, data: JSON.stringify({ p: "dsh-e2ee-probe-v1", t: 1, c: 0 }) });
-  svc.handleProbe(sessId, probe);
-  assert.equal(session.verified, true);
-  return { sessId, client, session };
-}
-
-test("① 加密落盘：文件里没有 MK/SHK/salt 明文，权限 0600，格式可自描述", () => {
-  const dir = tmpDir();
-  const svc = mkSvc();
-  const { sessId } = unlock(svc);
-  svc.attachStore(dir, { flushMs: 0 }); // unlock 时已即时落盘；attach 再恢复一次（空目录）
-  const r = svc.flushStore();
-  assert.equal(r.ok, true, "落盘应成功");
-  const file = sessionStorePath(dir);
-  assert.equal(path.basename(file), SESSION_STORE_FILE);
-  assert.ok(existsSync(file), "会话库文件应存在");
-  const raw = readFileSync(file, "utf8");
-  const shkB64 = svc.sessions.get(sessId).shk.toString("base64url");
-  assert.ok(!raw.includes(shkB64), "★ 文件里不得出现 SHK 明文");
-  assert.ok(!raw.includes(MK.toString("base64url")), "★ 文件里不得出现 MK 明文");
-  assert.ok(!raw.includes(SALT), "文件里不该有 salt 明文");
-  const blob = JSON.parse(raw);
-  assert.equal(blob.v, SESSION_STORE_VERSION);
-  assert.equal(blob.alg, "aes-256-gcm");
-  assert.ok(blob.iv && blob.tag && blob.ct, "iv/tag/ct 三件套齐全");
-  if (process.platform !== "win32") {
-    assert.equal(statSync(file).mode & 0o777, 0o600, "文件权限必须是 0600");
-  }
-  // 解密得回 payload（密钥只由 MK 派生）
-  const payload = decryptSessionStore(MK, blob);
-  assert.equal(payload.salt, SALT);
-  assert.equal(payload.sessions.length, 1);
-  assert.equal(payload.sessions[0].s, sessId);
-  // 用错误 MK 解密必须失败（信任边界：拿到文件也解不开）
-  assert.throws(() => decryptSessionStore(Buffer.alloc(32, 1), blob), /store_auth_failed|无法解密/);
-  svc.disposeStore();
-});
-
-test("② 重启恢复：新 E2eeService 只凭 MK + 目录恢复 verified 会话 + ctrl 计数，旧票可直接用", () => {
-  const dir = tmpDir();
-  const svc1 = mkSvc();
-  const { sessId, client } = unlock(svc1);
-  svc1.attachStore(dir, { flushMs: 0 });
-  svc1.ctrlCounters.get(sessId).p2b.last = 3; // 模拟解锁后又跑过探测
-  svc1.flushStore();
-  svc1.disposeStore();
-
-  // "重启"：全新服务实例，只凭 MK + 同一目录恢复
-  const svc2 = mkSvc();
-  const restored = svc2.attachStore(dir, { flushMs: 0 });
-  assert.equal(restored.restored, 1);
-  assert.equal(restored.discarded, "", "没有作废");
-  const session = svc2.sessionOf(sessId);
-  assert.ok(session, "★ 旧 sessId 必须仍可用（这正是持久化的目的）");
-  assert.equal(session.verified, true, "verified 也要恢复（否则数据 WS 仍被判 locked）");
-  assert.equal(svc2.ctrlCounters.get(sessId).p2b.last, 3, "ctrl 防重放计数必须恢复（重启不能重置）");
-  // 恢复的会话密钥仍能正确解密手机端的信封（HTTP 请求）
-  const plain = Buffer.from(JSON.stringify({ m: "GET", p: "/x", h: {}, b: "" }), "utf8");
-  const env = client.seal({ kind: "http", dir: "p2b", counter: 1, data: plain });
-  assert.doesNotThrow(() => svc2.guardHttpRequest(sessId, env), "恢复后的会话必须能过 guardHttpRequest");
-  const opened = session.open({ kind: "http", dir: "p2b", env, counter: env.c });
-  assert.equal(JSON.parse(opened.data.toString("utf8")).p, "/x");
-  svc2.disposeStore();
-});
-
-test("③ 失效路径：MK 变了（改密）→ 丢弃文件 + 清空内存 + 返回 key_mismatch", () => {
-  const dir = tmpDir();
-  const svc1 = mkSvc();
-  unlock(svc1);
-  svc1.attachStore(dir, { flushMs: 0 });
-  svc1.flushStore();
-  svc1.disposeStore();
-
-  const svc2 = new E2eeService({ enabled: true, mk: Buffer.alloc(32, 1), profile: PROFILE, salt: SALT, epoch: 1 });
-  const r = svc2.attachStore(dir, { flushMs: 0 });
-  assert.equal(r.restored, 0);
-  assert.equal(r.discarded, "key_mismatch", "必须报告失效原因（上层据此给手机 rehandshake 信号）");
-  assert.equal(svc2.sessions.size, 0, "不得把解不开的旧会话当活会话");
-  assert.equal(existsSync(sessionStorePath(dir)), false, "坏文件必须删掉，别让下次继续撞");
-  svc2.disposeStore();
-});
-
-test("④ 失效路径：salt 变化 → params_changed 丢弃；磁盘损坏 → corrupt/key_mismatch 丢弃", () => {
-  const dir = tmpDir();
-  const svc1 = mkSvc();
-  unlock(svc1);
-  svc1.attachStore(dir, { flushMs: 0 });
-  svc1.flushStore();
-  svc1.disposeStore();
-
-  // salt 变了（服务端参数更换）→ 即便 MK 碰巧能解开也不能复用（MK 域不同）
-  const svc2 = new E2eeService({ enabled: true, mk: MK, profile: PROFILE, salt: "salt-CHANGED", epoch: 1 });
-  const r2 = svc2.attachStore(dir, { flushMs: 0 });
-  assert.equal(r2.discarded, "params_changed");
-  assert.equal(svc2.sessions.size, 0);
-  assert.equal(existsSync(sessionStorePath(dir)), false);
-  svc2.disposeStore();
-
-  // 损坏文件（半截写 / 手工改）：认证失败 → 丢弃
-  const dir2 = tmpDir();
-  saveSessionStore(dir2, MK, { v: SESSION_STORE_VERSION, salt: SALT, profile: PROFILE, epoch: 1, sessions: [] });
-  const file = sessionStorePath(dir2);
-  const blob = JSON.parse(readFileSync(file, "utf8"));
-  blob.ct = `${blob.ct.slice(0, 8)}${blob.ct.slice(8).replace(/[A-Za-z]/g, "Z")}`;
-  writeFileSync(file, JSON.stringify(blob));
-  const svc3 = mkSvc();
-  const r3 = svc3.attachStore(dir2, { flushMs: 0 });
-  assert.equal(r3.restored, 0);
-  assert.ok(["corrupt", "key_mismatch"].includes(r3.discarded), `损坏文件必须被丢弃（实际 ${r3.discarded}）`);
-  assert.equal(svc3.sessions.size, 0);
-  svc3.disposeStore();
-
-  // 完全不是 JSON
-  const dir3 = tmpDir();
-  writeFileSync(sessionStorePath(dir3), "not-json");
-  const svc4 = mkSvc();
-  assert.equal(svc4.attachStore(dir3, { flushMs: 0 }).discarded, "corrupt");
-  svc4.disposeStore();
-});
-
-test("⑤ 24h 滑动 TTL 仍生效：过期会话不恢复，未过期的保留", () => {
-  const dir = tmpDir();
-  const now = Date.now();
-  const row = (sessId, usedAt) => ({
-    s: sessId,
-    shk: Buffer.alloc(32, 5).toString("base64url"),
-    saltH: Buffer.alloc(32, 6).toString("base64url"),
-    profile: PROFILE,
-    epoch: 1,
-    verified: true,
-    createdAt: usedAt - 1000,
-    usedAt,
-    p2b: -1,
-    b2p: -1
-  });
-  const fresh = newSessId();
-  const stale = newSessId();
-  const nearBoundary = newSessId();
-  saveSessionStore(dir, MK, {
-    v: SESSION_STORE_VERSION,
-    salt: SALT,
-    profile: PROFILE,
-    epoch: 1,
-    at: now,
-    sessions: [row(fresh, now - 60_000), row(stale, now - SESSION_TTL_MS - 5_000), row(nearBoundary, now - SESSION_TTL_MS + 60_000)]
-  });
-  const svc = mkSvc();
-  const r = svc.attachStore(dir, { flushMs: 0 });
-  assert.equal(r.restored, 2, "过期的那条必须被丢掉");
-  assert.ok(svc.sessionOf(fresh));
-  assert.ok(svc.sessionOf(nearBoundary), "TTL 内（哪怕接近边界）都要保留");
-  assert.equal(svc.sessionOf(stale), null);
-  svc.disposeStore();
-});
-
-test("⑥ 未启用 / 未给目录 / 目录不可写 → 静默降级（绝不因为会话库把隧道拖挂）", () => {
-  const dir = tmpDir();
-  const disabled = new E2eeService({ enabled: false, reason: "no_password" });
-  assert.equal(disabled.attachStore(dir).skipped, "e2ee_disabled");
-  assert.equal(existsSync(sessionStorePath(dir)), false, "未启用时不得写文件");
-
-  const svc = mkSvc();
-  assert.equal(svc.attachStore("").skipped, "no_dir");
-  assert.deepEqual(svc.flushStore(), { ok: false, skipped: true });
-
-  // 目录不可写（拿一个普通文件当目录）→ flush 返回 ok:false，但绝不抛
-  const fileAsDir = path.join(tmpDir(), "not-a-dir");
-  writeFileSync(fileAsDir, "x");
-  svc.attachStore(fileAsDir, { flushMs: 0 });
-  const r = svc.flushStore();
-  assert.equal(r.ok, false, "写失败只返回失败，不抛");
-  svc.disposeStore();
-});
-
-test("⑦ 原语契约：save→load→clear 往返；版本/AAD 域隔离；storeKey 确定性", () => {
-  const dir = tmpDir();
-  const payload = { v: SESSION_STORE_VERSION, salt: SALT, profile: PROFILE, epoch: 1, sessions: [{ s: newSessId(), usedAt: Date.now() }] };
-  assert.equal(saveSessionStore(dir, MK, payload).ok, true);
-  const loaded = loadSessionStore(dir, MK);
-  assert.equal(loaded.ok, true);
-  assert.equal(loaded.payload.sessions.length, 1);
-  // 换版本号 → 解不开（旧格式不能冒名顶替）
-  const blob = JSON.parse(readFileSync(sessionStorePath(dir), "utf8"));
-  assert.throws(() => decryptSessionStore(MK, { ...blob, v: 2 }), /会话库版本|bad_store/);
-  // clear 后读回 absent
-  assert.equal(clearSessionStore(dir), true);
-  assert.equal(loadSessionStore(dir, MK).reason, "absent");
-  // storeKey：同一个 MK 确定性一致；MK 非法直接拒绝（不静默）
-  assert.deepEqual(deriveSessionStoreKey(MK), deriveSessionStoreKey(MK));
-  assert.notDeepEqual(deriveSessionStoreKey(MK), deriveSessionStoreKey(Buffer.alloc(32, 1)));
-  assert.throws(() => deriveSessionStoreKey(Buffer.alloc(16)), /MK 非法/);
-});