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

package/clients/dsh-remote/e2ee-client.mjs

@@ -644,11 +644,6 @@ export class E2eeService {
     this.sessions = new Map(); // sessId → E2eeSession
     this.ctrlCounters = new Map(); // sessId → { p2b: SequenceGuard, b2p: SequenceGuard }
     this.httpNonces = new HttpNonceGuard();
-    // ── 会话持久化(可选,见文件末尾「会话持久化」段)──
-    this.storeDir = "";
-    this.storeTimer = null;
-    this.storeErrorLogged = false;
-    this.lastStoreReason = "";
   }
 
   /** 静态工厂:启动派生(失败即禁用并说明原因;绝不抛)。 */
@@ -723,130 +718,6 @@ export class E2eeService {
     return s || null;
   }
 
-  /* ── 会话持久化(2026-10-23)────────────────────────────────────────────────────
-   *
-   * 【为什么】生产日志：bridge 重启/崩溃后，手机端保存的 sessId 在内存表里找不到 →
-   *   每个请求 502 `unknown_session`、每条数据 WS 被 1008 `e2ee_session_locked` 拒，
-   *   用户被迫回设备列表重新解锁（实测某设备 3964 次）。
-   * 【怎么存】只存**不可推导的会话材料**（SHK / saltH / 验证标志 / 时间戳 / ctrl 计数器），
-   *   用 MK 派生出的 storeKey 做 AES-256-GCM 加密后落盘到 relay 数据目录
-   *   `.e2ee-sessions.enc`（0600，原子写）。文件里没有 MK、没有密码、没有 storeKey ——
-   *   拿到文件也解不开（同一份文件在不同账号/改密后的 MK 下 GCM 认证必失败）。
-   * 【失效纪律】解不开 / 版本不符 / salt 变了 → 丢弃文件 + 清空内存会话，并让上层给手机
-   *   回 `retryable:true, action:"rehandshake"` 的信号（自动重握手，而不是反复撞死票）。
-   *   HTTP 的防重放 nonce 窗口**不**持久化：它只有 5 分钟，重启丢窗的代价是"同一请求可能
-   *   在这 5 分钟内被重放一次"，而重放的前提是攻击者已经拿到那条完整密文请求 —— 与把
-   *   整份会话密钥落盘相比不改变信任边界（见 docs/e2ee-protocol.md §9.1）。
-   */
-  attachStore(dir, { enabled = true, flushMs = 60_000 } = {}) {
-    if (!enabled) return { restored: 0, discarded: "", skipped: "disabled" };
-    if (!this.enabled) return { restored: 0, discarded: "", skipped: "e2ee_disabled" };
-    if (!dir) return { restored: 0, discarded: "", skipped: "no_dir" };
-    this.storeDir = String(dir);
-    const r = this.restoreFromStore();
-    if (flushMs > 0) {
-      try {
-        this.storeTimer = setInterval(() => this.flushStore(), flushMs);
-        this.storeTimer.unref?.();
-      } catch { /* 定时器不可用 → 只有退出时 flush(不致命) */ }
-    }
-    return r;
-  }
-
-  /** 退出/测试用:停掉周期落盘。 */
-  disposeStore() {
-    if (this.storeTimer) { try { clearInterval(this.storeTimer); } catch { /* 忽略 */ } }
-    this.storeTimer = null;
-  }
-
-  /** 从磁盘恢复会话(同步、绝不抛)。返回 { restored, discarded, skipped? }。 */
-  restoreFromStore() {
-    if (!this.storeDir || !this.enabled) return { restored: 0, discarded: "" };
-    const loaded = loadSessionStore(this.storeDir, this.mk);
-    if (!loaded.ok) {
-      if (loaded.reason === "absent") return { restored: 0, discarded: "" };
-      // 解不开/损坏:删掉它，别让下一位继续撞。原因留给上层打日志 + 给手机 rehandshake 信号。
-      clearSessionStore(this.storeDir);
-      this.lastStoreReason = loaded.reason;
-      return { restored: 0, discarded: loaded.reason };
-    }
-    const payload = loaded.payload || {};
-    if (Number(payload.v) !== SESSION_STORE_VERSION || String(payload.salt || "") !== String(this.salt || "")) {
-      clearSessionStore(this.storeDir);
-      this.lastStoreReason = "params_changed";
-      return { restored: 0, discarded: "params_changed" };
-    }
-    const now = Date.now();
-    this.sessions.clear();
-    this.ctrlCounters.clear();
-    for (const row of Array.isArray(payload.sessions) ? payload.sessions : []) {
-      try {
-        const sessId = String(row && row.s || "");
-        if (!SESS_ID_RE.test(sessId)) continue;
-        const usedAt = Number(row.usedAt) || 0;
-        if (!usedAt || now - usedAt > SESSION_TTL_MS) continue; // 过期(sliding TTL)
-        const session = new E2eeSession({
-          sessId,
-          shk: Buffer.from(String(row.shk || ""), "base64url"),
-          saltH: Buffer.from(String(row.saltH || ""), "base64url"),
-          profile: String(row.profile || this.profile),
-          epoch: Number(row.epoch) || 0
-        });
-        session.verified = row.verified === true;
-        session.createdAt = Number(row.createdAt) || usedAt;
-        session.usedAt = usedAt;
-        this.sessions.set(sessId, session);
-        const guards = { p2b: new SequenceGuard(), b2p: new SequenceGuard() };
-        if (Number.isInteger(row.p2b)) guards.p2b.last = row.p2b;
-        if (Number.isInteger(row.b2p)) guards.b2p.last = row.b2p;
-        this.ctrlCounters.set(sessId, guards);
-      } catch { /* 单条坏 → 跳过,不影响其它会话 */ }
-    }
-    this.prune();
-    return { restored: this.sessions.size, discarded: "" };
-  }
-
-  /**
-   * 落盘一次(同步、绝不抛)。force=false 时只在 storeDir 存在时写。
-   * 写失败只记一次日志:会话库不是主链路,不能因为它把隧道拖挂。
-   */
-  flushStore() {
-    if (!this.storeDir || !this.enabled) return { ok: false, skipped: true };
-    try {
-      const payload = {
-        v: SESSION_STORE_VERSION,
-        profile: this.profile,
-        epoch: this.epoch,
-        salt: this.salt,
-        at: Date.now(),
-        sessions: [...this.sessions.values()].map((s) => ({
-          s: s.sessId,
-          shk: s.shk.toString("base64url"),
-          saltH: s.saltH.toString("base64url"),
-          profile: s.profile,
-          epoch: s.epoch,
-          verified: s.verified === true,
-          createdAt: s.createdAt,
-          usedAt: s.usedAt,
-          p2b: this.ctrlCounters.get(s.sessId)?.p2b?.last ?? -1,
-          b2p: this.ctrlCounters.get(s.sessId)?.b2p?.last ?? -1
-        }))
-      };
-      return saveSessionStore(this.storeDir, this.mk, payload);
-    } catch (e) {
-      if (!this.storeErrorLogged) {
-        this.storeErrorLogged = true;
-        console.warn(`[e2ee] 会话库落盘失败(不影响隧道,仅本次重启需重新解锁): ${e?.code || e?.message || e}`);
-      }
-      return { ok: false, error: String(e?.code || e?.message || e) };
-    }
-  }
-
-  /** 新会话建立/验证通过后立即落盘(解锁不常有,同步写 2KB 可接受;崩溃也不丢新会话)。 */
-  persistSoon() {
-    try { this.flushStore(); } catch { /* 已内部兜底 */ }
-  }
-
   /**
    * 桥端应答 e2ee-hello(§5.2 步骤 1→2)。
    * @returns {{session:E2eeSession, ack:object}} 或抛 E2eeError
@@ -876,7 +747,6 @@ export class E2eeService {
     const session = new E2eeSession({ sessId, shk, saltH, profile: this.profile, epoch: this.epoch });
     this.sessions.set(sessId, session);
     this.ctrlCounters.set(sessId, { p2b: new SequenceGuard(), b2p: new SequenceGuard() });
-    this.persistSoon(); // 新会话立刻落盘:紧接着的 bridge 崩溃不该让手机重新解锁
     const ack = {
       v: E2EE_VERSION,
       type: CTRL_HELLO_ACK,
@@ -914,7 +784,6 @@ export class E2eeService {
       data: JSON.stringify({ p: "dsh-e2ee-probe-ok", t: pt.t ?? 0, c: 0 })
     });
     this.ctrlCounters.set(sessId, guards);
-    this.persistSoon(); // verified 也落盘:重启后数据 WS 直接可用,不必再探测
     return { reply, session };
   }
 
@@ -928,126 +797,6 @@ export class E2eeService {
   }
 }
 
-// ============================================================
-// 会话持久化原语(2026-10-23;方案/信任边界见 E2eeService.attachStore 上方长注释)
-// ============================================================
-
-export const SESSION_STORE_VERSION = 1;
-export const SESSION_STORE_FILE = ".e2ee-sessions.enc";
-/** 会话库 AAD(域分隔;换格式/换用途必须改它,旧文件自动解不开 → 丢弃重握手)。 */
-export const SESSION_STORE_AAD = Buffer.from(`${E2EE_DOMAIN}\x00sessions-store-v1`, "utf8");
-
-/** 会话库路径(与 .e2ee-state.json 同级,relay 数据目录)。 */
-export function sessionStorePath(dir) {
-  return `${String(dir || "").replace(/[\\/]+$/, "")}/${SESSION_STORE_FILE}`;
-}
-
-/**
- * 由 MK 派生会话库密钥:
- *   storeKey = HKDF-SHA256(ikm=MK, salt=sha256("dsh-e2ee/v1\0sessions-store-salt"),
- *                          info="dsh-e2ee/v1\0sessions-store", 32)
- * 与 SHK/子密钥域完全隔离;storeKey 只驻内存,绝不写文件、不写日志。
- */
-export function deriveSessionStoreKey(mk) {
-  if (!Buffer.isBuffer(mk) || mk.length !== MK_BYTES) throw new E2eeError("bad_mk", "e2ee: 会话库 MK 非法");
-  const salt = sha256(Buffer.from(`${E2EE_DOMAIN}\x00sessions-store-salt`, "utf8"));
-  return Buffer.from(hkdfSync("sha256", mk, salt, Buffer.from(`${E2EE_DOMAIN}\x00sessions-store`, "utf8"), MK_BYTES));
-}
-
-/** 加密会话库 → 可直接 JSON.stringify 的对象(明文永不落盘)。 */
-export function encryptSessionStore(mk, payload) {
-  const key = deriveSessionStoreKey(mk);
-  const iv = randomBytes(NONCE_BYTES);
-  const plaintext = Buffer.from(JSON.stringify(payload), "utf8");
-  const c = createCipheriv("aes-256-gcm", key, iv);
-  c.setAAD(SESSION_STORE_AAD);
-  const ct = Buffer.concat([c.update(plaintext), c.final()]);
-  return {
-    v: SESSION_STORE_VERSION,
-    alg: "aes-256-gcm",
-    iv: iv.toString("base64url"),
-    tag: c.getAuthTag().toString("base64url"),
-    ct: ct.toString("base64url")
-  };
-}
-
-/** 解密会话库;任何异常都抛 E2eeError(调用方据此丢弃文件)。 */
-export function decryptSessionStore(mk, blob) {
-  if (!blob || typeof blob !== "object") throw new E2eeError("bad_store", "e2ee: 会话库格式非法");
-  if (Number(blob.v) !== SESSION_STORE_VERSION) throw new E2eeError("bad_store", `e2ee: 会话库版本 ${blob.v} 不受支持`);
-  if (String(blob.alg || "") !== "aes-256-gcm") throw new E2eeError("bad_store", "e2ee: 会话库算法不受支持");
-  const key = deriveSessionStoreKey(mk);
-  const iv = Buffer.from(String(blob.iv || ""), "base64url");
-  const tag = Buffer.from(String(blob.tag || ""), "base64url");
-  const ct = Buffer.from(String(blob.ct || ""), "base64url");
-  if (iv.length !== NONCE_BYTES || tag.length !== TAG_BYTES) throw new E2eeError("bad_store", "e2ee: 会话库 nonce/tag 非法");
-  const d = createDecipheriv("aes-256-gcm", key, iv);
-  d.setAAD(SESSION_STORE_AAD);
-  d.setAuthTag(tag);
-  let plaintext;
-  try {
-    plaintext = Buffer.concat([d.update(ct), d.final()]); // 认证失败(MK 变了/被篡改)在这里抛
-  } catch {
-    throw new E2eeError("store_auth_failed", "e2ee: 会话库无法解密(MK 已变或文件损坏)");
-  }
-  try {
-    return JSON.parse(plaintext.toString("utf8"));
-  } catch {
-    throw new E2eeError("bad_store", "e2ee: 会话库明文不是 JSON");
-  }
-}
-
-/** 原子写会话库(mkdir + tmp 文件 + rename;0600)。失败抛(上层兜)。 */
-export function saveSessionStore(dir, mk, payload) {
-  if (!dir) throw new E2eeError("no_store_dir", "e2ee: 会话库目录未设置");
-  const file = sessionStorePath(dir);
-  const body = JSON.stringify(encryptSessionStore(mk, payload));
-  const tmp = `${file}.tmp-${process.pid}`;
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(tmp, body, { mode: 0o600 });
-  try { fs.chmodSync(tmp, 0o600); } catch { /* Windows 上可能不支持 */ }
-  fs.renameSync(tmp, file); // rename 原子:不会读到半截文件
-  return { ok: true, bytes: body.length, file };
-}
-
-/** 读会话库。返回 { ok, reason: absent|unreadable|corrupt|key_mismatch, payload }(绝不抛)。 */
-export function loadSessionStore(dir, mk) {
-  const file = sessionStorePath(dir);
-  let raw;
-  try {
-    raw = fs.readFileSync(file, "utf8");
-  } catch (e) {
-    return { ok: false, reason: e?.code === "ENOENT" ? "absent" : "unreadable", payload: null, file };
-  }
-  let blob;
-  try {
-    blob = JSON.parse(raw);
-  } catch {
-    return { ok: false, reason: "corrupt", payload: null, file };
-  }
-  try {
-    return { ok: true, reason: "", payload: decryptSessionStore(mk, blob), file };
-  } catch (e) {
-    return {
-      ok: false,
-      reason: e?.code === "store_auth_failed" ? "key_mismatch" : "corrupt",
-      payload: null,
-      file
-    };
-  }
-}
-
-/** 删除会话库(丢弃死会话时用;返回是否真的删掉)。 */
-export function clearSessionStore(dir) {
-  if (!dir) return false;
-  try {
-    fs.rmSync(sessionStorePath(dir), { force: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 /** 把 E2EE 开关状态写入 relayDir/.e2ee-state.json(供 Phase-4 面板 UI 读取)。 */
 export function writeE2eeStateFile(dir, state) {
   try {

package/clients/dsh-remote/mobile-adapter.mjs

@@ -3973,267 +3973,6 @@ const SCRIPT = `(() => {
         } catch (ePs) { /* 忽略 */ }
       });
     } catch (ePs2) { /* 忽略 */ }
-  /* ===DSH-MA-SINGLEPAGE-START===
-     同一设备只允许一个镜像页（2026-10-23，生产现场：手机端会出现同一 deviceId 的两个镜像页
-     并发，互相取消资源加载 → 两边都一直转圈）。
-
-     做法（同步优先，绝不拖慢首个页面）：
-       1. 只对 /remote/<deviceId>/ 形态的镜像页生效；设备列表/登录页不参与。
-       2. **同步租约**：localStorage 里一条 {id, at}，本页心跳每 2s 刷新。读到"别人的租约且新鲜
-          （<6s）"→ 立刻进 blocked 态（不依赖任何异步 API 就能把第二页按住）。
-       3. 再叠加 BroadcastChannel：新页 claim / takeover / release 实时互通，
-          老页收到 claim/takeover 立刻让路（显示"已切到另一窗口"）。
-       4. 有 Web Locks 时再拿一把同名锁兜底（双开竞态的最后仲裁者）。
-       5. blocked 态 = window.stop() + 拦掉 fetch/XHR send/WebSocket + 全屏提示（带"在本窗口继续"
-          按钮，点了通知旧页让路 → 本页重载接管）。同时每 2s 复查租约：旧页关掉/失联后自动恢复。
-       6. 老浏览器（没有 localStorage/BroadcastChannel，如部分隐私模式）→ 直接不启用，
-          保持既有行为（宁可不管，也绝不能把唯一页面锁死）。
-
-     注入体纪律：本段不得出现反引号，只用 ES5 语法。 */
-  function maSinglePageGuard() {
-    try {
-      var LS_KEY_PREFIX = "dsh-remote-mirror-page:";
-      var BC_PREFIX = "dsh-remote-mirror-page-bc:";
-      var LEASE_TTL_MS = 6000;
-      var BEAT_MS = 2000;
-      var LOCK_PREFIX = "dsh-remote-mirror-lock:";
-      var OVERLAY_ID = "dsh-ma-singlepage";
-      var BTN_ID = "dsh-ma-singlepage-takeover";
-
-      var loc = (typeof location !== "undefined" && location) ? location : (window.location || null);
-      if (!loc) return;
-      // 只认 /remote/<deviceId>/ 形态（用 split 解析：注入体是模板字符串，正则里的 \/ 会被吃掉）
-      var seg = String(loc.pathname || "").split("/").filter(Boolean);
-      if (seg[0] !== "remote" || !seg[1]) return;
-      var dev = "";
-      try { dev = decodeURIComponent(seg[1]); } catch (eDec) { dev = ""; }
-      if (!dev || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(dev)) return;
-      var key = LS_KEY_PREFIX + dev;
-      var takeoverKey = key + ":takeover";
-      var self = "p" + Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
-
-      var ls = null;
-      try { ls = window.localStorage || null; } catch (e0) { ls = null; }
-      var bc = null;
-      try {
-        if (typeof window.BroadcastChannel === "function") bc = new window.BroadcastChannel(BC_PREFIX + dev);
-      } catch (e1) { bc = null; }
-      if (!ls || !bc) return; // 老浏览器/隐私模式:不改变既有行为(不锁)
-
-      var state = "checking";
-      var beatTimer = 0;
-      var pollTimer = 0;
-      var claimedAt = 0;
-
-      function publish(s) {
-        state = s;
-        try {
-          window.__dshSinglePage = { state: s, device: dev };
-        } catch (eP) { /* 忽略 */ }
-      }
-
-      function readLease() {
-        try {
-          var raw = ls.getItem(key);
-          if (!raw) return null;
-          var v = JSON.parse(raw);
-          if (!v || typeof v.id !== "string") return null;
-          return { id: v.id, at: Number(v.at) || 0 };
-        } catch (eR) { return null; }
-      }
-      function writeLease() {
-        try { ls.setItem(key, JSON.stringify({ id: self, at: Date.now() })); } catch (eW) { /* 忽略 */ }
-      }
-      function releaseLease() {
-        try {
-          var cur = readLease();
-          if (cur && cur.id === self) ls.removeItem(key);
-        } catch (eL) { /* 忽略 */ }
-      }
-      function readTakeover() {
-        try { return Number(ls.getItem(takeoverKey)) || 0; } catch (eT) { return 0; }
-      }
-      function markTakeover() {
-        try { ls.setItem(takeoverKey, String(Date.now())); } catch (eM) { /* 忽略 */ }
-      }
-
-      function post(msg) {
-        try { bc.postMessage(msg); } catch (ePo) { /* 忽略 */ }
-      }
-
-      function reload() {
-        try {
-          if (typeof loc.reload === "function") { loc.reload(); return; }
-          loc.href = loc.href;
-        } catch (eRel) { /* 忽略 */ }
-      }
-
-      /* ---- 第二页：即刻停掉加载 + 全屏提示（唯一出口是「在本窗口继续」或回原窗口）---- */
-      function installNetworkStop() {
-        try { if (typeof window.stop === "function") window.stop(); } catch (eS) { /* 忽略 */ }
-        try {
-          if (typeof window.fetch === "function") {
-            window.fetch = function () {
-              return Promise.reject(new Error("dsh-single-page: 同一设备的镜像页已在另一个窗口打开，本页已停用"));
-            };
-          }
-        } catch (eF) { /* 忽略 */ }
-        try {
-          var proto = window.XMLHttpRequest && window.XMLHttpRequest.prototype;
-          if (proto && typeof proto.send === "function") {
-            proto.send = function () { try { this.abort(); } catch (eX) { /* 忽略 */ } };
-          }
-        } catch (eXhr) { /* 忽略 */ }
-        try {
-          if (typeof window.WebSocket === "function") {
-            var WsBlocked = function () {
-              throw new Error("dsh-single-page: 同一设备的镜像页已在另一个窗口打开，本页已停用");
-            };
-            WsBlocked.prototype = window.WebSocket.prototype;
-            window.WebSocket = WsBlocked;
-          }
-        } catch (eWs) { /* 忽略 */ }
-      }
-
-      function buildOverlay() {
-        try {
-          if (!document || !document.body) return;
-          if (document.getElementById && document.getElementById(OVERLAY_ID)) return;
-          var wrap = document.createElement("div");
-          wrap.id = OVERLAY_ID;
-          wrap.setAttribute("data-dsh-single-page", "blocked");
-          wrap.style.cssText = "position:fixed;left:0;top:0;right:0;bottom:0;z-index:2147483001;"
-            + "background:#0f1115;color:#e8eaed;display:flex;align-items:center;justify-content:center;"
-            + "padding:24px;box-sizing:border-box;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,sans-serif;";
-          wrap.innerHTML = '<div style="max-width:420px;text-align:center;line-height:1.7">'
-            + '<div style="font-size:18px;font-weight:600;margin-bottom:10px">该设备已在本浏览器另一个窗口打开</div>'
-            + '<div style="font-size:14px;color:#9aa0a6;margin-bottom:18px">两个镜像页同时加载会互相取消资源加载，'
-            + '导致两边都卡住。请回到原来那个窗口继续使用。</div>'
-            + '<button id="' + BTN_ID + '" style="border:0;border-radius:10px;padding:12px 18px;'
-            + 'font-size:15px;background:#3b82f6;color:#fff;width:100%">在本窗口继续（切换到本页）</button>'
-            + '</div>';
-          document.body.appendChild(wrap);
-          var btn = document.getElementById ? document.getElementById(BTN_ID) : null;
-          if (btn && typeof btn.addEventListener === "function") btn.addEventListener("click", takeover, false);
-        } catch (eOv) { /* 提示失败也不影响"已停用"这个事实 */ }
-      }
-
-      function showOverlay() {
-        try {
-          if (document && document.body) buildOverlay();
-          else if (document && typeof document.addEventListener === "function") {
-            document.addEventListener("DOMContentLoaded", buildOverlay, false);
-          }
-        } catch (eShow) { /* 忽略 */ }
-      }
-
-      function becomeBlocked(why) {
-        if (state === "blocked") return;
-        publish("blocked");
-        try { if (beatTimer) { clearInterval(beatTimer); beatTimer = 0; } } catch (eB) { /* 忽略 */ }
-        releaseLease();
-        installNetworkStop();
-        showOverlay();
-        try {
-          if (!pollTimer) {
-            pollTimer = setInterval(function () {
-              var l = readLease();
-              var now = Date.now();
-              if (l && l.id !== self && now - l.at < LEASE_TTL_MS) return; // 人家还活着
-              // 原来的窗口关了/失联:允许自己接管(先打 takeover 标记,避免重载后又被自己挡住)
-              try { if (pollTimer) { clearInterval(pollTimer); pollTimer = 0; } } catch (eC) { /* 忽略 */ }
-              markTakeover();
-              reload();
-            }, 2000);
-          }
-        } catch (ePoll) { /* 忽略 */ }
-        if (window.console && console.info) console.info("[dsh-mobile-adapter] 单镜像页:第二页已停用(" + why + ")");
-      }
-
-      function takeover() {
-        post({ k: "takeover", id: self, at: Date.now() });
-        markTakeover();
-        // 给旧页 400ms 收消息、释放租约、让出资源，然后本页重载（重载后按 takeover 标记直接接管）
-        setTimeout(reload, 400);
-      }
-
-      function beat() {
-        writeLease();
-      }
-
-      function becomeActive() {
-        publish("active");
-        claimedAt = Date.now();
-        // takeover 标记只用于「重载后允许接管一次」：拿到租约后立刻消费掉，
-        // 否则它在 15s 有效期内会让第三个页面也以为自己可以接管（并发又回来了）。
-        try { ls.removeItem(takeoverKey); } catch (eCl) { /* 忽略 */ }
-        writeLease();
-        try {
-          if (!beatTimer) beatTimer = setInterval(beat, BEAT_MS);
-        } catch (eBt) { /* 忽略 */ }
-        post({ k: "claim", id: self, at: claimedAt });
-        // Web Locks 兜底（可用时）：并发双开时只有拿到锁的那个页面继续
-        try {
-          var nav = window.navigator;
-          if (nav && nav.locks && typeof nav.locks.request === "function") {
-            nav.locks.request(LOCK_PREFIX + dev, { ifAvailable: true }, function (lock) {
-              if (!lock) { becomeBlocked("web_locks_busy"); return undefined; }
-              return new Promise(function () { /* 持有到页面结束 */ });
-            }).catch(function () { /* 不支持 ifAvailable/被拒 → 租约已足够 */ });
-          }
-        } catch (eLocks) { /* 忽略 */ }
-        // 让路：另一页 claim（它后发/并发）或要求接管
-        try {
-          bc.onmessage = function (ev) {
-            var msg = ev && ev.data;
-            if (!msg || typeof msg !== "object") return;
-            if (msg.id === self) return;
-            if (msg.k === "takeover") {
-              becomeBlocked("takeover");
-              return;
-            }
-            if (msg.k === "claim" && Number(msg.at) >= claimedAt) {
-              // 同一时刻两个页面都认为自己是活跃页（同步租约竞态）→ 按 id 字典序让一个走
-              if (Number(msg.at) === claimedAt && String(msg.id) < String(self)) return;
-              becomeBlocked("other_claim");
-            }
-          };
-        } catch (eMsg) { /* 忽略 */ }
-        try {
-          window.addEventListener("pagehide", function () {
-            if (state !== "active") return;
-            // 进 bfcache / 切走：让出租约，别让另一个页面（或用户重开）被一张"僵尸租约"挡住
-            releaseLease();
-            post({ k: "release", id: self, at: Date.now() });
-            if (beatTimer) { try { clearInterval(beatTimer); } catch (eBt2) { /* 忽略 */ } beatTimer = 0; }
-            try { bc.onmessage = null; } catch (eBc2) { /* 忽略 */ } // 卸载旧监听，避免和 pageshow 后的新实例抢状态
-            publish("inactive");
-          });
-          // bfcache 回来：可能已经过了很久、也可能别的页面已经接管 → 重新判一次（幂等）
-          window.addEventListener("pageshow", function (ev) {
-            if (!ev || !ev.persisted) return;
-            if (state === "active") return;
-            try { maSinglePageGuard(); } catch (ePs) { /* 忽略 */ }
-          });
-        } catch (ePh) { /* 忽略 */ }
-      }
-
-      /* ---- 启动：同步租约判定（关键：不 await，第二页在网络请求发出前就被按住）---- */
-      var now = Date.now();
-      var lease = readLease();
-      var tko = readTakeover();
-      var takeoverFresh = tko > 0 && now - tko < 15000 && tko <= now + 60000;
-      var foreignFresh = lease && lease.id !== self && lease.at <= now + 60000 && now - lease.at < LEASE_TTL_MS;
-      if (foreignFresh && !takeoverFresh) {
-        becomeBlocked("lease_held");
-        return;
-      }
-      becomeActive();
-    } catch (e) { /* 守卫绝不能把页面拖挂 */ }
-  }
-  maSinglePageGuard();
-  /* ===DSH-MA-SINGLEPAGE-END=== */
-
   } catch (e) { if (window.console) console.warn("[dsh-mobile-adapter]", e && e.message); }
 })();`;
 

package/clients/dsh-remote/test/bridge-upstream-refresh.test.mjs

@@ -8,10 +8,6 @@
  * HTTP 失败路径早就会 refreshUpstream，**WS 失败路径之前漏了** —— 而镜像页常先开 WS。
  *
  * 这个用例守住：两条失败路径都必须触发重新发现（否则又回到"只能重启 bridge"）。
- *
- * 【2026-10-23 契约变更】ws-open 改为「先快速 ack、再连上游」后，上游建立失败的收尾从
- *   `{type:"ws-open", ok:false, code:502}` 变成 `{type:"ws-close", code:1011, retryable:true}`
- *   —— 升级早已完成，再回 ws-open 失败帧没有意义。自愈要求不变：仍必须 refreshUpstream。
  */
 import test from "node:test";
 import assert from "node:assert/strict";
@@ -19,28 +15,14 @@ import { readFileSync } from "node:fs";
 
 const SRC = readFileSync(new URL("../dsh-bridge.mjs", import.meta.url), "utf8");
 
-/** 取某个锚点到下一处 `\n}` 的函数体（够做源代码契约断言，不追求通用解析）。 */
-function bodyAfter(anchor, maxLen = 2000) {
-  const i = SRC.indexOf(anchor);
-  assert.ok(i > 0, `找不到锚点：${anchor}`);
-  return SRC.slice(i, i + maxLen);
-}
-
-test("★ WS 上游建立失败必须触发上游重新发现（快速应答后走 ws-close 1011）", () => {
-  // ws.on("error") 的未建立分支 → 统一交给 failUpstream 收尾
-  const errBranch = bodyAfter('ws.on("error"', 900);
-  assert.match(errBranch, /!session\.opened/, "只对未建立的会话做失败收尾");
-  assert.match(errBranch, /failUpstream\(/, "未建立失败必须走统一收尾（不要各写一份）");
-  // failUpstream 内部：重发现 + ws-close（升级已 ack，不能再回 ws-open）
-  const failFn = bodyAfter("const failUpstream =", 2200);
-  assert.match(failFn, /refreshUpstream\(/, "★ 必须触发重新发现，否则端口变了会一直失败");
-  assert.match(failFn, /failAckedWs\(/, "快速应答之后只能 ws-close 收尾");
-  const ackFn = bodyAfter("function failAckedWs(", 600);
-  assert.match(ackFn, /type: "ws-close"/, "收尾帧必须是 ws-close");
-  assert.match(ackFn, /code: 1011/, "ws-close 用 1011(服务端内部错误)");
-  // close 路径也要覆盖「还没 open 就断」：不能只靠 error 事件
-  const closeBranch = bodyAfter('ws.on("close"', 900);
-  assert.match(closeBranch, /failUpstream\(/, "上游没建立就 close 也要触发重发现");
+test("★ WS 打开失败必须触发上游重新发现（不只是回 502）", () => {
+  // 找到 ws.on("error" ...) 的未建立分支
+  const i = SRC.indexOf('ws.on("error"');
+  assert.ok(i > 0, "必须有 ws error 处理");
+  const branch = SRC.slice(i, i + 1200);
+  assert.match(branch, /!session\.opened/, "只对未建立的会话做 502");
+  assert.match(branch, /refreshUpstream\(/, "★ 必须触发重新发现，否则端口变了会一直 502");
+  assert.match(branch, /code: 502/, "行为不变：本次仍然回 502");
 });
 
 test("★ HTTP 失败路径也要有重新发现（既有能力不得回退）", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.7.5-beta.1",
+  "version": "0.7.6-beta.1",
   "description": "手机远程控制 DeepSeek Harness · Remote control DeepSeek Harness (dsh web) from any phone browser — 100% 全功能 App 级体验：发消息、看工具执行、审批权限、改设置、管凭据，含特权操作，免内网穿透。一条命令安装 npx @mrrisega/dsh-remote。Mobile remote control for DSH, self-host or SaaS, no server needed on LAN.",
   "keywords": [
     "deepseek-harness",