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

package/clients/dsh-remote/test/mobile-adapter-single-page.test.mjs

@@ -1,328 +0,0 @@
-#!/usr/bin/env node
-/**
- * 手机端「同一 deviceId 只允许一个镜像页」回归（2026-10-23）。
- *
- * 生产现场：手机端会出现同一设备的两个镜像页并发（重复打开 / 从历史里点回来），
- *   两边互相取消资源加载 → 都一直转圈。
- *
- * 注入体里的守卫（mobile-adapter 的 DSH-MA-SINGLEPAGE 段）契约：
- *   ① 第一个页面：同步写租约（localStorage）+ BroadcastChannel claim，正常加载；
- *   ② 第二个页面：同步读到"别人的新鲜租约"→ 立刻 blocked（window.stop + 拦 fetch/XHR/WS
- *      + 全屏提示），**不写租约、不加载**；
- *   ③ 「在本窗口继续」：广播 takeover → 旧页让路并释放租约 → 本页 400ms 后重载接管；
- *   ④ 旧页关掉/失联（租约过期）→ blocked 页自动重载接管，不会永久卡在提示层；
- *   ⑤ 非镜像页（设备列表/登录页）、老浏览器（无 localStorage/BroadcastChannel）→ 零行为。
- *
- * 本文件跑的是注入脚本里**真实的那一段**（vm + 假 DOM），断言的是行为不是文本。
- */
-import assert from "node:assert/strict";
-import test from "node:test";
-import vm from "node:vm";
-import { injectMobileAdapter } from "../mobile-adapter.mjs";
-
-/** 注入脚本里取出单页守卫那一段（含结尾的调用）。 */
-function guardSource() {
-  const { html } = injectMobileAdapter("<!doctype html><html><head></head><body></body></html>");
-  const m = /<script id="[^"]*-js"[^>]*>([\s\S]*?)<\/script>/.exec(html);
-  assert.ok(m, "应能取出注入脚本");
-  const js = m[1];
-  const start = "/* ===DSH-MA-SINGLEPAGE-START===";
-  const end = "/* ===DSH-MA-SINGLEPAGE-END=== */";
-  const a = js.indexOf(start);
-  const b = js.indexOf(end);
-  assert.ok(a > 0 && b > a, "找不到单页守卫的段落标记（脚本结构变了，请同步更新本用例）");
-  return js.slice(a, b + end.length);
-}
-
-const SRC = guardSource();
-
-// ── 假环境（同一"浏览器"的多个页面共享 storage 与 BroadcastChannel 总线）──────────
-
-const NOW0 = 1_700_000_000_000;
-
-function makeGroup() {
-  return {
-    store: new Map(),
-    channels: new Set(),
-    messages: [],
-    clock: { now: NOW0 }
-  };
-}
-
-function makeStorage(group) {
-  return {
-    getItem(k) { return group.store.has(k) ? group.store.get(k) : null; },
-    setItem(k, v) { group.store.set(k, String(v)); },
-    removeItem(k) { group.store.delete(k); }
-  };
-}
-
-class FakeBC {
-  constructor(group, name) {
-    this.group = group;
-    this.name = name;
-    this.onmessage = null;
-    group.channels.add(this);
-  }
-  postMessage(msg) {
-    this.group.messages.push(msg);
-    // 浏览器里是异步投递；用例里同步投递（同源多页面），断言更直接
-    for (const peer of this.group.channels) {
-      if (peer === this) continue;
-      if (typeof peer.onmessage === "function") peer.onmessage({ data: msg });
-    }
-  }
-  close() { this.group.channels.delete(this); }
-}
-
-/** 极简假 DOM：只支持守卫用到的那点能力（createElement/body.appendChild/getElementById）。 */
-function makeDoc() {
-  const appended = [];
-  const buttons = new Map();
-  const makeEl = (tag) => {
-    const el = {
-      tagName: String(tag).toUpperCase(),
-      id: "",
-      attrs: {},
-      style: { cssText: "" },
-      innerHTML: "",
-      children: [],
-      _listeners: new Map(),
-      setAttribute(n, v) { this.attrs[n] = String(v); },
-      getAttribute(n) { return n in this.attrs ? this.attrs[n] : null; },
-      addEventListener(type, fn) { (this._listeners.get(type) || this._listeners.set(type, []).get(type)).push(fn); },
-      appendChild(c) { this.children.push(c); return c; }
-    };
-    return el;
-  };
-  const body = makeEl("body");
-  const doc = {
-    body,
-    _appended: appended,
-    createElement: makeEl,
-    addEventListener() {},
-    getElementById(id) {
-      const found = appended.find((el) => el.id === id || el.attrs.id === id);
-      if (found) return found;
-      // 提示层里的「在本窗口继续」按钮：innerHTML 里定义了 id，按需造一个可点击元素
-      const overlay = appended.find((el) => el.id === "dsh-ma-singlepage");
-      if (overlay && overlay.innerHTML.includes(`id="${id}"`)) {
-        if (!buttons.has(id)) {
-          const btn = makeEl("button");
-          btn.id = id;
-          buttons.set(id, btn);
-        }
-        return buttons.get(id);
-      }
-      return null;
-    }
-  };
-  body.appendChild = (el) => { appended.push(el); return el; };
-  return doc;
-}
-
-function makeEnv(group, { pathname = "/remote/dev-A/", withBC = true, withStorage = true } = {}) {
-  const timers = { intervals: new Map(), timeouts: new Map(), seq: 0 };
-  const doc = makeDoc();
-  const storage = withStorage ? makeStorage(group) : null;
-  const state = { stops: 0, reloads: 0, messages: [] };
-  const loc = {
-    pathname,
-    href: `https://relay.example${pathname}`,
-    reload() { state.reloads += 1; }
-  };
-  const FakeDate = class extends Date {
-    static now() { return group.clock.now; }
-  };
-  const win = {
-    localStorage: storage,
-    // 真实 window.navigator 有 locks 就用（老 Safari 没有）；这里默认不给，测租约路径
-    navigator: {},
-    location: loc,
-    addEventListener(type, fn) { state.messages.push(type); (win._ls || (win._ls = [])).push({ type, fn }); },
-    _ls: [],
-    stop() { state.stops += 1; },
-    fetch: () => Promise.resolve({ ok: true }),
-    XMLHttpRequest: class { send() {} abort() {} },
-    WebSocket: class { constructor() { this.readyState = 1; } },
-    console
-  };
-  if (withBC) win.BroadcastChannel = class extends FakeBC { constructor(name) { super(group, name); } };
-  const sandbox = {
-    window: win,
-    document: doc,
-    location: loc,
-    localStorage: storage,
-    console,
-    Promise,
-    Date: FakeDate,
-    Math,
-    JSON,
-    Object,
-    Array,
-    String,
-    Number,
-    Boolean,
-    RegExp,
-    Error,
-    decodeURIComponent,
-    isNaN,
-    parseInt,
-    parseFloat,
-    setInterval: (fn, ms) => { const id = ++timers.seq; timers.intervals.set(id, { fn, ms, ticks: 0 }); return id; },
-    clearInterval: (id) => { timers.intervals.delete(id); },
-    setTimeout: (fn, ms) => { const id = ++timers.seq; timers.timeouts.set(id, { fn, ms }); return id; },
-    clearTimeout: (id) => { timers.timeouts.delete(id); }
-  };
-  vm.runInNewContext(SRC, sandbox, { filename: "mobile-adapter#singlepage" });
-  const api = {
-    win,
-    doc,
-    loc,
-    sandbox,
-    timers,
-    state,
-    get appState() { return win.__dshSinglePage ? win.__dshSinglePage.state : ""; },
-    /** 跑一轮 2s 轮询（blocked 页的租约复查）。 */
-    tickPoll() {
-      for (const t of timers.intervals.values()) { if (t.ms === 2000) t.fn(); }
-    },
-    runTimeouts() {
-      for (const [id, t] of [...timers.timeouts]) { timers.timeouts.delete(id); t.fn(); }
-    },
-    clickTakeover() {
-      const btn = doc.getElementById("dsh-ma-singlepage-takeover");
-      assert.ok(btn, "提示层里必须有「在本窗口继续」按钮");
-      const fns = btn._listeners.get("click") || [];
-      assert.ok(fns.length > 0, "按钮必须绑定了点击处理");
-      for (const fn of fns) fn({ type: "click" });
-    },
-    dispatchWindow(type, extra = {}) {
-      for (const l of win._ls || []) if (l.type === type) l.fn({ type, ...extra });
-    },
-    lease() {
-      const raw = storage && storage.getItem(`dsh-remote-mirror-page:${pathname.split("/")[2]}`);
-      return raw ? JSON.parse(raw) : null;
-    },
-    storeGet(key) { return storage ? storage.getItem(key) : null; },
-    storeSet(key, val) { if (storage) storage.setItem(key, val); }
-  };
-  return api;
-}
-
-// ── 用例 ──────────────────────────────────────────────────────────────────────
-
-test("① 第一个页面：同步写租约 + 广播 claim，正常加载", () => {
-  const g = makeGroup();
-  const a = makeEnv(g);
-  assert.equal(a.appState, "active", "第一个页面必须是活跃页");
-  const lease = a.lease();
-  assert.ok(lease && typeof lease.id === "string", "必须写入租约");
-  assert.equal(lease.at, NOW0);
-  const claim = g.messages.find((m) => m.k === "claim");
-  assert.ok(claim, "必须广播 claim（让后来的页面知道有人）");
-  assert.equal(a.state.stops, 0, "活跃页不得停掉自己的加载");
-});
-
-test("② 第二个页面：同步识破别人的租约 → 立刻 blocked（stop + 拦网络 + 提示），且不写租约", async () => {
-  const g = makeGroup();
-  const first = makeEnv(g);
-  const second = makeEnv(g);
-  assert.equal(second.appState, "blocked", "第二页必须被按住");
-  assert.equal(second.state.stops, 1, "必须 window.stop()（停止后续资源加载）");
-  const overlay = second.doc.getElementById("dsh-ma-singlepage");
-  assert.ok(overlay, "必须给出可见提示（不是静默卡住）");
-  assert.equal(overlay.getAttribute("data-dsh-single-page"), "blocked");
-  assert.match(overlay.innerHTML, /另一个窗口/, "提示文案要点明「已在另一个窗口打开」");
-  assert.match(overlay.innerHTML, /在本窗口继续/, "必须给「在本窗口继续」出口");
-  // 拦网络：fetch 拒绝、WebSocket 不可用
-  await assert.rejects(() => second.win.fetch("/api/x"), /本页已停用/);
-  assert.throws(() => new second.win.WebSocket("ws://x"), /本页已停用/);
-  // 不许抢租约：租约仍属于第一页
-  assert.equal(second.lease().id, first.lease().id, "第二页绝不能覆盖第一页的租约");
-});
-
-test("③ 「在本窗口继续」：广播 takeover → 旧页让路并释放租约 → 本页重载接管", () => {
-  const g = makeGroup();
-  const first = makeEnv(g);
-  const second = makeEnv(g);
-  const firstLeaseId = first.lease().id;
-
-  second.clickTakeover();
-  // 旧页收到 takeover：立刻让路（进入 blocked、释放租约）
-  assert.equal(first.appState, "blocked", "旧页必须让路，不能两边都继续加载");
-  assert.equal(first.lease(), null, "旧页必须释放租约");
-  assert.ok(g.messages.some((m) => m.k === "takeover"), "必须广播 takeover");
-  // 本页 400ms 后重载（重载后按 takeover 标记直接接管）
-  assert.equal(second.state.reloads, 0, "还没到重载时间");
-  second.runTimeouts();
-  assert.equal(second.state.reloads, 1, "接管方必须重载一次，拿干净页面");
-  // 重载后的路径：租约可能还在 + 有 takeover 标记 → 允许接管（否则自己把自己锁死）
-  const reloaded = makeEnv(g);
-  assert.equal(reloaded.appState, "active", "takeover 标记有效期内的重载必须能接管");
-  assert.equal(reloaded.lease().id !== firstLeaseId, true, "接管后租约归属接管方");
-  // 关键：takeover 标记必须"用掉即消费"，否则有效期内第三个页面也会以为自己能接管
-  const third = makeEnv(g);
-  assert.equal(third.appState, "blocked", "接管完成后，再开的页面仍必须被按住（不允许并发第三个）");
-});
-
-test("④ 旧页关掉/失联（租约过期）→ blocked 页自动重载接管，不会永久卡住", () => {
-  const g = makeGroup();
-  makeEnv(g); // 第一页写完租约后"关掉了"（不再心跳）
-  const second = makeEnv(g);
-  assert.equal(second.appState, "blocked");
-  // 时间前进到租约过期之后
-  g.clock.now = NOW0 + 7000;
-  second.tickPoll();
-  assert.equal(second.state.reloads, 1, "租约过期后必须自动重载接管");
-  assert.ok(second.storeGet("dsh-remote-mirror-page:dev-A:takeover"), "重载前要留 takeover 标记（避免重载后又被自己挡住）");
-});
-
-test("⑤ 活跃页 pagehide 时释放租约；bfcache 回来（pageshow persisted）重新判定", () => {
-  const g = makeGroup();
-  const a = makeEnv(g);
-  assert.ok(a.lease());
-  a.dispatchWindow("pagehide");
-  assert.equal(a.lease(), null, "pagehide 必须释放租约");
-  assert.equal(a.appState, "inactive", "pagehide 后不再是活跃页");
-  // bfcache 回来：租约已释放 → 重新判定后重新成为活跃页
-  a.dispatchWindow("pageshow", { persisted: true });
-  assert.equal(a.appState, "active", "bfcache 恢复后必须重新判定并接管");
-  assert.ok(a.lease(), "恢复后要重新写租约");
-  // 另一个页面此刻打开 → 它看到租约并被按住（不会两个页面并发加载）
-  const b = makeEnv(g);
-  assert.equal(b.appState, "blocked");
-});
-
-test("⑥ 非镜像页 / 老浏览器 → 零行为（绝不把唯一页面锁死）", () => {
-  // /app/ 设备列表页不参与单页约束
-  const g1 = makeGroup();
-  const app = makeEnv(g1, { pathname: "/app/" });
-  assert.equal(app.appState, "", "非镜像页不得介入");
-  assert.equal(g1.store.size, 0, "非镜像页不得写任何 localStorage");
-  assert.equal(app.doc._appended.length, 0, "非镜像页不得往页面塞任何节点");
-
-  // 没有 BroadcastChannel（部分老浏览器/隐私模式）→ 不启用
-  const g2 = makeGroup();
-  const noBc = makeEnv(g2, { withBC: false });
-  assert.equal(noBc.appState, "", "没有 BroadcastChannel 时不得启用（不锁）");
-  assert.equal(g2.store.size, 0);
-  assert.equal(noBc.doc._appended.length, 0);
-
-  // 没有 localStorage → 不启用
-  const g3 = makeGroup();
-  const noLs = makeEnv(g3, { withStorage: false });
-  assert.equal(noLs.appState, "", "没有 localStorage 时不得启用");
-  assert.equal(noLs.doc._appended.length, 0);
-});
-
-test("⑦ 同一时刻两个页面都从空租约启动（并发竞态）→ 后到的看到租约后被按住", () => {
-  const g = makeGroup();
-  // 用同一份 group 串行模拟"几乎同时"：第一个先写入租约（JS 单线程，真实世界也是先到先得）
-  const a = makeEnv(g);
-  const b = makeEnv(g);
-  assert.equal(a.appState, "active");
-  assert.equal(b.appState, "blocked");
-  // 两个页面不会互相写坏租约
-  assert.equal(a.lease().id, b.lease().id, "租约归属第 1 页，第 2 页不覆盖");
-});

package/packages/dsh-remote-web/test/community-invite-proxy.test.mjs

@@ -1,343 +0,0 @@
-// 🎉 企微交流群引导（使用满 2 小时弹一次）—— **宿主半边**（lib/index.js）代理路由回归。
-//
-// 背景（业主 2026-10-23 需求）：用户实际使用满 2 小时后要「加入企业微信群」引导，
-// 每用户全局只弹一次；手机 Web 端已实现，桌面端插件面板复用**同一套企业端接口**：
-//   GET  /api/community-invite/status → { ok, show, reason, used_seconds, required_seconds, qr_url }
-//   POST /api/community-invite/shown  → { ok:true }（幂等）
-//
-// 桌面端浏览器半没有企业端用户 token 直连，所以本文件锁 node 半两条代理路由的契约：
-//   GET  /dsh-remote/community-invite/status → 上游 GET  {api}/api/community-invite/status
-//   POST /dsh-remote/community-invite/shown  → 上游 POST {api}/api/community-invite/shown
-//
-// 最要紧的四件（都是"写错就出事故"的点）：
-//   ① 身份只认本机 device-login token，**不透传浏览器带来的 Authorization**；
-//   ② 判定/记账全在服务端：show/reason/时长字段原样透传，node 半**不自己算**；
-//   ③ qr_url 归一化成企业端绝对地址（相对路径在 dsh web 源上会解析到 127.0.0.1），
-//      非 http(s)/站内路径一律丢弃（前端降级），绝不把 data:/javascript: 交给 <img src>；
-//   ④ 一切失败软着陆：未登录/自建 → 200 + ok:false（面板静默）；上游 4xx/5xx 透传；
-//      不可达 → 502 JSON，**绝不抛回 webServer**（否则面板会看到 500 堆栈）。
-import assert from "node:assert/strict";
-import http from "node:http";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-import { apply } from "../lib/index.js";
-
-/** 假 relay：device-login 发 token；community-invite 两个端点按 opts 返回（并记录收到的请求）。 */
-async function startFakeRelay(opts = {}) {
-  const seen = [];
-  const srv = http.createServer((req, res) => {
-    let raw = "";
-    req.on("data", (c) => { raw += c; });
-    req.on("end", () => {
-      const entry = { method: req.method, url: req.url, headers: req.headers, body: raw };
-      seen.push(entry);
-      const send = (code, obj) => {
-        res.writeHead(code, { "content-type": "application/json" });
-        res.end(JSON.stringify(obj));
-      };
-      const url = new URL(req.url, "http://x");
-      // 模拟"token 拿到了、但企业端 community-invite 端点不可达"：直接掐连接（fetch 端表现为 status 0）
-      if (opts.killCommunity && url.pathname.startsWith("/api/community-invite")) {
-        try { req.socket.destroy(); } catch { /* 忽略 */ }
-        return;
-      }
-      if (req.method === "POST" && url.pathname === "/api/device-login") {
-        // device-login 失败场景：返回 401（插件 node 半应静默降级成 not_logged_in）
-        if (opts.loginStatus && opts.loginStatus !== 200) return send(opts.loginStatus, { error: { code: "bad_credentials", message: "密码错误" } });
-        return send(200, { token: "jwt-abc" });
-      }
-      if (url.pathname === "/api/community-invite/status") {
-        if (opts.statusCode && opts.statusCode !== 200) {
-          return send(opts.statusCode, { error: { code: "boom", message: "服务端炸了" } });
-        }
-        return send(200, opts.statusBody || {
-          ok: true,
-          show: true,
-          reason: "ok",
-          used_seconds: 7205,
-          required_seconds: 7200,
-          qr_url: "/qr/group-qr.png"
-        });
-      }
-      if (req.method === "POST" && url.pathname === "/api/community-invite/shown") {
-        return send(200, { ok: true });
-      }
-      send(404, { error: { code: "not_found" } });
-    });
-  });
-  await new Promise((r) => srv.listen(0, "127.0.0.1", r));
-  return { srv, seen, base: `http://127.0.0.1:${srv.address().port}` };
-}
-
-function boot(relayDir) {
-  const routes = new Map();
-  apply({
-    webServer: { register(rt) { routes.set(rt.path, rt.handler); return () => {}; } },
-    effect(reg) { return reg(); },
-    logger: { info() {}, warn() {} },
-  }, { relayDir });
-  const host = http.createServer((req, res) => {
-    const url = new URL(req.url, "http://x");
-    // 与 announcements-proxy.test.mjs 对齐：注册对象只有 {kind,path,handler}，
-    // prefix 路由的 handler 自己判别子路径（没有 route.prefix 字段）。
-    const handler = routes.get(url.pathname) || routes.get("/dsh-remote/community-invite");
-    (handler || ((_r, rs) => { rs.writeHead(404); rs.end(); }))(req, res);
-  });
-  return host;
-}
-
-const writeCfg = (relayDir, apiUrl, extra = {}) => writeFile(path.join(relayDir, ".dsh-config.json"), JSON.stringify({
-  device_id: "dev-ci-1", api_url: apiUrl, phone: "13800000000", password: "pw", ...extra,
-}));
-
-/** 只挑 community-invite 的上游请求（插件装载时还会打 public-config / device-login 等旁路请求）。 */
-const ciReqs = (up) => up.seen.filter((e) => String(e.url || "").startsWith("/api/community-invite"));
-
-async function withPlugin(fn) {
-  const relayDir = await mkdtemp(path.join(os.tmpdir(), "dsh-ci-"));
-  process.env.DSH_RELAY_SKIP_SERVICE = "1"; // 套件级隔离：绝不真的去后台装运行环境
-  let host = null;
-  try {
-    return await fn({ relayDir, startHost: () => { host = boot(relayDir); return host; } });
-  } finally {
-    try { if (host) host.close(); } catch { /* 忽略 */ }
-    process.env.DSH_RELAY_SKIP_SERVICE = "1"; // 恢复（不要 delete：套件本来就靠它隔离）
-    await rm(relayDir, { recursive: true, force: true });
-  }
-}
-
-async function listen(host) {
-  await new Promise((r) => host.listen(0, "127.0.0.1", r));
-  return `http://127.0.0.1:${host.address().port}`;
-}
-
-test("GET status：device-login token 打企业端，show/qr_url 原样透传（qr_url 归一化成绝对地址）", async () => {
-  const up = await startFakeRelay();
-  try {
-    await withPlugin(async ({ relayDir, startHost }) => {
-      await writeCfg(relayDir, up.base);
-      const base = await listen(startHost());
-      const r = await (await fetch(`${base}/dsh-remote/community-invite/status`)).json();
-      assert.equal(r.ok, true);
-      assert.equal(r.show, true);
-      assert.equal(r.reason, "ok");
-      assert.equal(r.used_seconds, 7205, "时长口径由服务端算，node 半只透传");
-      assert.equal(r.required_seconds, 7200);
-      assert.equal(r.qr_url, `${up.base}/qr/group-qr.png`, "相对路径必须拼成企业端绝对地址（否则图片落在 127.0.0.1 上打不开）");
-
-      const got = ciReqs(up).find((e) => e.method === "GET" && e.url === "/api/community-invite/status");
-      assert.ok(got, "必须真的打到企业端 GET /api/community-invite/status");
-      assert.equal(got.headers.authorization, "Bearer jwt-abc", "必须用 device-login 换来的 token（sub = user）");
-    });
-  } finally {
-    up.srv.close();
-  }
-});
-
-test("GET status：show=false（未满 2h / 已弹过 / 没配二维码）原样透传，node 半绝不自己算", async () => {
-  const up = await startFakeRelay({
-    statusBody: { ok: true, show: false, reason: "already_shown", used_seconds: 9000, required_seconds: 7200, qr_url: "/qr/group-qr.png" }
-  });
-  try {
-    await withPlugin(async ({ relayDir, startHost }) => {
-      await writeCfg(relayDir, up.base);
-      const base = await listen(startHost());
-      const r = await (await fetch(`${base}/dsh-remote/community-invite/status`)).json();
-      assert.equal(r.ok, true);
-      assert.equal(r.show, false, "服务端说不弹就不弹");
-      assert.equal(r.reason, "already_shown", "reason 要透传（面板/排障用）");
-      assert.equal(r.used_seconds, 9000);
-    });
-  } finally {
-    up.srv.close();
-  }
-});
-
-test("GET status：qr_url 为空 / 非法协议（data:/javascript:/协议相对）→ 下发空串（前端降级）", async () => {
-  for (const bad of ["", "  ", "data:image/png;base64,AAA", "javascript:alert(1)", "//evil.example/qr.png"]) {
-    const up = await startFakeRelay({
-      statusBody: { ok: true, show: true, reason: "ok", used_seconds: 7300, required_seconds: 7200, qr_url: bad }
-    });
-    try {
-      await withPlugin(async ({ relayDir, startHost }) => {
-        await writeCfg(relayDir, up.base);
-        const base = await listen(startHost());
-        const r = await (await fetch(`${base}/dsh-remote/community-invite/status`)).json();
-        assert.equal(r.show, true, `show 仍然透传（${JSON.stringify(bad)}）`);
-        assert.equal(r.qr_url, "", `非法/空 qr_url 必须下发空串，交给前端降级（实际 ${JSON.stringify(r.qr_url)}）`);
-      });
-    } finally {
-      up.srv.close();
-    }
-  }
-});
-
-test("POST shown：幂等上报打到企业端 POST /api/community-invite/shown（Bearer）", async () => {
-  const up = await startFakeRelay();
-  try {
-    await withPlugin(async ({ relayDir, startHost }) => {
-      await writeCfg(relayDir, up.base);
-      const base = await listen(startHost());
-      const res = await fetch(`${base}/dsh-remote/community-invite/shown`, { method: "POST" });
-      assert.equal(res.status, 200);
-      const r = await res.json();
-      assert.equal(r.ok, true);
-      const got = ciReqs(up).find((e) => e.method === "POST" && e.url === "/api/community-invite/shown");
-      assert.ok(got, "必须真的打到企业端 POST /api/community-invite/shown");
-      assert.equal(got.headers.authorization, "Bearer jwt-abc");
-      // 上报两次也必须都成功（幂等契约：展示时一次 + 关闭时一次）
-      const again = await (await fetch(`${base}/dsh-remote/community-invite/shown`, { method: "POST" })).json();
-      assert.equal(again.ok, true);
-      assert.equal(ciReqs(up).filter((e) => e.method === "POST").length, 2, "两次上报都要转发（服务端幂等）");
-    });
-  } finally {
-    up.srv.close();
-  }
-});
-
-test("鉴权：没配账号 → 200 + ok:false/not_logged_in，且完全不碰企业端（不白跑 device-login）", async () => {
-  const up = await startFakeRelay();
-  try {
-    await withPlugin(async ({ relayDir, startHost }) => {
-      await writeCfg(relayDir, up.base, { phone: "", password: "" });
-      const base = await listen(startHost());
-      const r = await (await fetch(`${base}/dsh-remote/community-invite/status`)).json();
-      assert.equal(r.ok, false);
-      assert.equal(r.show, false, "未登录绝不能让面板弹引导");
-      assert.equal(r.reason, "not_logged_in");
-      assert.equal(ciReqs(up).length, 0, "不得向企业端发任何 community-invite 请求");
-      assert.equal(up.seen.filter((e) => e.url === "/api/device-login").length, 0, "没凭据就不该尝试 device-login");
-    });
-  } finally {
-    up.srv.close();
-  }
-});
-
-test("鉴权：自建（local_key）没有企业端账号体系 → local_mode，不发请求", async () => {
-  const up = await startFakeRelay();
-  try {
-    await withPlugin(async ({ relayDir, startHost }) => {
-      await writeCfg(relayDir, up.base, { phone: "", password: "", local_key: "selfhost-key" });
-      const base = await listen(startHost());
-      const r = await (await fetch(`${base}/dsh-remote/community-invite/status`)).json();
-      assert.equal(r.ok, false);
-      assert.equal(r.show, false);
-      assert.equal(r.reason, "local_mode");
-      assert.equal(ciReqs(up).length, 0, "自建模式不得请求企业端");
-    });
-  } finally {
-    up.srv.close();
-  }
-});
-
-test("鉴权：device-login 换 token 失败 → 静默 not_logged_in（面板不弹、不报错）", async () => {
-  const up = await startFakeRelay({ loginStatus: 401 });
-  try {
-    await withPlugin(async ({ relayDir, startHost }) => {
-      await writeCfg(relayDir, up.base);
-      const base = await listen(startHost());
-      const res = await fetch(`${base}/dsh-remote/community-invite/status`);
-      assert.equal(res.status, 200, "对面板而言是静默降级，不是 500");
-      const r = await res.json();
-      assert.equal(r.ok, false);
-      assert.equal(r.show, false);
-      assert.equal(r.reason, "not_logged_in");
-    });
-  } finally {
-    up.srv.close();
-  }
-});
-
-test("错误语义：企业端 401/500 → 状态码透传 + ok:false + 可读 error（面板依旧静默）", async () => {
-  for (const code of [401, 500]) {
-    const up = await startFakeRelay({ statusCode: code });
-    try {
-      await withPlugin(async ({ relayDir, startHost }) => {
-        await writeCfg(relayDir, up.base);
-        const base = await listen(startHost());
-        const res = await fetch(`${base}/dsh-remote/community-invite/status`);
-        assert.equal(res.status, code, "上游状态码透传（排障能看见，不伪装成 200）");
-        const r = await res.json();
-        assert.equal(r.ok, false);
-        assert.equal(r.show, false);
-        assert.equal(r.reason, "status_failed");
-        assert.ok(String(r.error || "").length > 0, "必须给可读错误");
-      });
-    } finally {
-      up.srv.close();
-    }
-  }
-});
-
-test("软着陆：整个企业端不可达（连 token 都拿不到）→ 200 + not_logged_in，面板不弹不报错", async () => {
-  await withPlugin(async ({ relayDir, startHost }) => {
-    // 指向一个一定没人监听的端口
-    await writeCfg(relayDir, "http://127.0.0.1:1");
-    const base = await listen(startHost());
-    const res = await fetch(`${base}/dsh-remote/community-invite/status`);
-    assert.equal(res.status, 200, "拿不到 token 属于'未登录'，不是服务端错误（面板静默）");
-    const r = await res.json();
-    assert.equal(r.ok, false);
-    assert.equal(r.show, false);
-    assert.equal(r.reason, "not_logged_in");
-  });
-});
-
-test("错误语义：token 拿到了但企业端 community-invite 端点不可达 → 502 JSON（路由自身绝不抛）", async () => {
-  const up = await startFakeRelay({ killCommunity: true });
-  try {
-    await withPlugin(async ({ relayDir, startHost }) => {
-      await writeCfg(relayDir, up.base);
-      const base = await listen(startHost());
-      const res = await fetch(`${base}/dsh-remote/community-invite/status`);
-      assert.equal(res.status, 502, "已确认登录、失败发生在上游请求 → 502（排障可见，不是静默 200）");
-      const r = await res.json();
-      assert.equal(r.ok, false);
-      assert.equal(r.show, false);
-      assert.equal(r.reason, "status_failed");
-      assert.ok(String(r.error || "").length > 0);
-      // 路由本身绝不能把异常抛回 webServer（那会变成 500 + 堆栈）
-      assert.notEqual(res.status, 500);
-    });
-  } finally {
-    up.srv.close();
-  }
-});
-
-test("未知子路径 / 错误方法 → 404，不代理到奇怪的上游路径", async () => {
-  const up = await startFakeRelay();
-  try {
-    await withPlugin(async ({ relayDir, startHost }) => {
-      await writeCfg(relayDir, up.base);
-      const base = await listen(startHost());
-      for (const [p, method] of [["/dsh-remote/community-invite/other", "GET"], ["/dsh-remote/community-invite/status", "POST"], ["/dsh-remote/community-invite/shown", "GET"]]) {
-        const res = await fetch(`${base}${p}`, { method });
-        assert.equal(res.status, 404, `${method} ${p} 必须 404`);
-        const r = await res.json();
-        assert.equal(r.reason, "unknown_route");
-      }
-      assert.equal(ciReqs(up).length, 0, "未知路由绝不请求企业端");
-    });
-  } finally {
-    up.srv.close();
-  }
-});
-
-test("身份纪律：浏览器带来的 Authorization **不透传**（用户级接口只认本机 node 半 token）", async () => {
-  const up = await startFakeRelay();
-  try {
-    await withPlugin(async ({ relayDir, startHost }) => {
-      await writeCfg(relayDir, up.base);
-      const base = await listen(startHost());
-      await fetch(`${base}/dsh-remote/community-invite/status`, { headers: { authorization: "Bearer browser-forged" } });
-      const got = ciReqs(up).find((e) => e.method === "GET");
-      assert.ok(got);
-      assert.equal(got.headers.authorization, "Bearer jwt-abc",
-        "身份必须是本机 device-login 换来的 token；浏览器带的 token 不能替代（否则'谁的身份'就含糊了）");
-    });
-  } finally {
-    up.srv.close();
-  }
-});