@mrrisega/dsh-remote 0.7.11-beta.3 → 0.7.12-beta.1

package/packages/dsh-remote-web/lib/index.js

@@ -210,6 +210,38 @@ async function discoverUpstreamSelf(relayDir, { force = false } = {}) {
   return upstreamDiscoveryInFlight;
 }
 
+/**
+ * 上游地址是否已经"够用"（不需要在**响应路径里现扫**）。
+ * 【B1 · 2026-11-07】登录/首屏慢的主因之一就是在响应路径里 await 端口发现。
+ * 只要下面任一成立就够用：显式 env / 已知监听端口 / TTL 内的发现结果 / 测试隔离 / 平台模拟。
+ */
+function upstreamDiscoverySettled() {
+  // 测试钩子**最优先**（true=强制"未 settled"，false=强制"已 settled"；null=不干预）：
+  // DSH 宿主里跑测试时环境常带 DSH_WEB_URL（会被 boundWebPort 认成"已知端口"），
+  // 不放在最前面就没法模拟"端口未知、需要发现"的现场。
+  if (upstreamForceUnsettled === true) return false;
+  if (upstreamForceUnsettled === false) return true;
+  if (String(process.env.DSH_BRIDGE_UPSTREAM || "").trim()) return true;
+  if (boundWebPort()) return true;
+  if (discoveredUpstream.url && Date.now() - discoveredUpstream.at < UPSTREAM_DISCOVERY_TTL_MS) return true;
+  if (skipsSystemOps()) return true;
+  if (osPlatform() !== process.platform) return true;
+  return false;
+}
+
+/** 测试钩子：替换发现实现 / 强制"未 settled"（只给用例用，生产永远走真实实现）。 */
+let discoverImpl = discoverUpstreamSelf;
+let upstreamForceUnsettled = null;
+function setUpstreamTestState(opts = {}) {
+  if (typeof opts.discover === "function") discoverImpl = opts.discover;
+  if (typeof opts.unsettled === "boolean") upstreamForceUnsettled = opts.unsettled;
+  return { discover: discoverImpl, unsettled: upstreamForceUnsettled };
+}
+function resetUpstreamTestState() {
+  discoverImpl = discoverUpstreamSelf;
+  upstreamForceUnsettled = null;
+}
+
 /**
  * 把上游地址落盘（`<relayDir>/.dsh-upstream`），供**没有环境变量**的那些守护读取：
  * 开机自启的 watcher（Windows 登录任务 / launchd）由系统拉起，拿不到本进程的 env，
@@ -1461,7 +1493,7 @@ function writeLinuxUnit(relayDir) {
   if (!unitPath) return null;
   const setup = join(relayDir, "dsh-setup.mjs");
   const unit = `[Unit]
-Description=dsh-remote bridge (auto-starts with dsh web)
+Description=dsh-remote-web bridge (auto-starts with dsh web)
 
 [Service]
 ExecStart=${NODE_BIN} ${setup} run
@@ -1648,6 +1680,31 @@ function launchTarget() {
  */
 const NO_LAUNCHD = { running: false, pid: null, state: "", runs: null, lastExitCode: null, crashing: false };
 
+// ── B1：shell 探测短 TTL 缓存（2026-11-07 登录慢优化）─────────────────────────────
+// launchctl / ps / systemctl 每次调用都是一次进程 spawn（实测 30~120ms，慢机器更久），
+// 而状态轮询 2.5s 一次会反复重跑同一份"没变"的事实。这里给 10s TTL：
+//   · 结论按 key 缓存；**变更动作（启动/停止/卸载/账号切换）会主动清缓存**，不会让面板显示过期状态。
+const STATUS_PROBE_TTL_MS = 10 * 1000;
+const statusProbeCache = new Map();
+function memoStatusProbe(key, fn) {
+  // 测试/诊断隔离下**不缓存**：这类环境里 shell 探测是假命令/假结果（skipsSystemOps 或 DSH_TEST_*
+  // 注入的 fake PATH），缓存只会让用例互相污染（一个用例伪造的 pid/服务状态被下一个用例读到 → 假红）。
+  // 生产路径（真实 launchctl/ps）才走 10s TTL。
+  if (skipsSystemOps()) return fn();
+  try {
+    if (Object.keys(process.env).some((k) => k.startsWith("DSH_TEST_"))) return fn();
+  } catch { /* 忽略 */ }
+  const now = Date.now();
+  const hit = statusProbeCache.get(key);
+  if (hit && now - hit.at < STATUS_PROBE_TTL_MS) return hit.value;
+  const value = fn();
+  statusProbeCache.set(key, { at: now, value });
+  return value;
+}
+function clearStatusProbeCache() {
+  try { statusProbeCache.clear(); } catch { /* 忽略 */ }
+}
+
 function launchdStatus() {
   // 非 macOS 没有 launchctl（Windows 上连 process.getuid 都没有）：直接返回「无此服务」，
   // 不再去 shell 里调一个不存在的命令——这既避免 500，也避免每次轮询白起一个 cmd.exe。
@@ -2655,6 +2712,7 @@ function stopBridgeDetached(relayDir, opts = {}) {
 
 /** 启动 bridge：确保运行环境就绪 + plist 存在 → launchctl bootstrap（回退 load -w）。 */
 function startBridge(relayDir) {
+  clearStatusProbeCache(); // B1：状态变更 → 立刻作废 shell 探测缓存，避免显示过期状态
   if (UNINSTALLED_DIRS.has(relayDir)) {
     // 已彻底卸载：面板/自愈在重启前可能仍在内存中，禁止再把自启动与 plist 拉回来
     return { ok: false, status: "uninstalled", detail: "插件已彻底卸载，重启 dsh web 后生效" };
@@ -2872,6 +2930,7 @@ const lastSelfhealReadyLine = new Map();
 
 /** 停止 bridge：macOS 走 launchctl bootout；Linux 走 systemd/脱离进程；Windows 结束 watcher/bridge 进程。 */
 function stopBridge(relayDir) {
+  clearStatusProbeCache(); // B1：状态变更 → 立刻作废 shell 探测缓存，避免显示过期状态
   if (isWindows()) return stopBridgeDetached(relayDir);
   // 测试隔离：置位时绝不对真实 launchd/systemd 下手（切换账号也会走到这里，
   // 少了这一条，用例就会去 bootout 开发者本机上真实运行的 bridge —— 实测过的污染风险）。
@@ -4008,8 +4067,9 @@ function maskPhone(p) {
 
 async function composeStatus(relayDir) {
   const cfg = loadConfig(relayDir);
-  const launchd = launchdStatus();
-  const manual = manualStatus(relayDir);
+  // B1：同样的 10s 缓存（状态轮询时不重复 spawn launchctl/ps）。
+  const launchd = memoStatusProbe("launchd", launchdStatus);
+  const manual = memoStatusProbe("manual:" + relayDir, () => manualStatus(relayDir));
   // 注册/绑定失败提示(bridge 写 .bind-error.json;面板据此展示“已达上限/需解绑”引导)
   let bindError = null;
   try {
@@ -5704,12 +5764,18 @@ async function accountDeviceBound(relayDir, cfg) {
  */
 async function composeConnect(relayDir, opts = {}) {
   const cfg = opts.cfg || loadConfig(relayDir);
-  // 【0.6.15】上游端口问不出来时，先主动发现一次再算阶段：否则诊断里永远是"3080 不可达"，
-  // 而用户的 dsh web 其实好好地跑在 2298（飞牛/NAS 实测）—— 面板与用户都会往"改端口"这个
-  // 错误方向使劲。发现很快（本机回环，全失败也就几百毫秒），失败不影响任何既有行为。
-  await discoverUpstreamSelf(relayDir).catch(() => FALLBACK_UPSTREAM);
-  const launchd = opts.launchd || launchdStatus();
-  const manual = opts.manual || manualStatus(relayDir);
+  // 【B1 · 2026-11-07 登录慢优化】端口发现**绝不再阻塞状态/登录响应**：
+  //   · 已有可用结论（显式 env / 已知监听端口 / TTL 内的发现结果 / 测试隔离）→ 直接用；
+  //   · 否则**放后台**跑（void），本次先用 hint/回退地址把状态返回 —— 首屏不再等信息；
+  //     发现完成后的结果会在下一次状态轮询自然带上（面板每 2.5~30s 轮询，无需推送）。
+  //   旧实现的 await 会把 lsof/netstat + 数百端口探测整个塞进首屏路径（业主实测 7~8 秒）。
+  const discoverySettled = upstreamDiscoverySettled();
+  if (!discoverySettled) {
+    void discoverImpl(relayDir).catch(() => FALLBACK_UPSTREAM);
+  }
+  // B1：这两次 shell 探测走 10s TTL 缓存（见 memoStatusProbe）；变更动作会清缓存。
+  const launchd = opts.launchd || memoStatusProbe("launchd", launchdStatus);
+  const manual = opts.manual || memoStatusProbe("manual:" + relayDir, () => manualStatus(relayDir));
   const book = connectBook(relayDir);
   const now = Date.now();
   const hasAcct = hasAccountCreds(cfg);
@@ -5958,6 +6024,8 @@ async function composeConnect(relayDir, opts = {}) {
     selfhealExhausted: selfhealGuardOf(relayDir).count >= SELFHEAL_MAX_RESTARTS,
     upstreamUrl: upstreamUrl(),
     upstreamSource: upstreamSourceLabel(),
+    // B1：这次响应是否"端口发现还没完成、已放后台跑"（只作诊断/文案；下一次轮询会自然收敛）
+    discoveryPending: Boolean(!discoverySettled),
     // 宿主形态：桌面端（Electron）与 Web 版（node）在若干动作上语义不同 ——
     // 最典型的是「重启 DeepSeek harness」在桌面端做不到也不该做（Host 由 Electron 托管，
     // 强行退出会弹原生致命错误）。面板据此改文案/去掉无意义的按钮，而不是等用户点了才失败。
@@ -7627,6 +7695,24 @@ function wecomStatusOf(status) {
     boundSessionId: str(w.boundSessionId),
     // 「上次预览卡片」已处理到的时间戳（桥写；面板只用来显示「上次预览：HH:MM」）
     lastPreviewCardAt: num(w.lastPreviewCardAt),
+    // ── 会员档位 / 额度（2026-11-07 桥侧新增，字段名锁死；只白名单，不整包吐）──
+    // tier 只认三个枚举值；拿不到就是空串（面板据此**不渲染**档位条，绝不猜）。
+    tier: (() => {
+      const t = str(w.tier);
+      return (t === "free" || t === "pro" || t === "pro_max") ? t : "";
+    })(),
+    // caps 是字符串数组：逐个转字符串 + 截断 + 上限 50 条（桥以后往里塞对象也别透出去）
+    caps: (Array.isArray(w.caps) ? w.caps : []).slice(0, 50).map((c) => str(c).slice(0, 80)).filter(Boolean),
+    capsCount: num(w.capsCount),
+    bindingGated: !!w.bindingGated,
+    messagesPerMonth: num(w.messagesPerMonth),
+    // null = 不限或未知（**必须和 0 区分**：0 条剩余 ≠ 不限量）
+    remainingMessages: typeof w.remainingMessages === "number" && Number.isFinite(w.remainingMessages) ? w.remainingMessages : null,
+    usage: (() => {
+      const u = w.usage && typeof w.usage === "object" ? w.usage : null;
+      if (!u) return null;
+      return { month: str(u.month), messages: num(u.messages) };
+    })(),
     sessions: (Array.isArray(w.sessions) ? w.sessions : []).slice(0, 50).map(function (it) {
       const o = it && typeof it === "object" ? it : {};
       return {
@@ -8290,7 +8376,26 @@ function registerRoutes(ctx, relayDir, opts = {}) {
         const bridgeRestart = startBridge(relayDir);
         // 登录成功即上报本机安装信息（企业端用于「升级插件后刷新版本号」约定）；失败静默。
         maybeReportInstall(relayDir, { force: true });
-        sendJson(res, 200, { ok: true, bridgeRestart, ...(await composeStatus(relayDir)) });
+        // 【B2 · 2026-11-07】登录响应**立即返回**：旧实现 `...(await composeStatus())` 会把
+        // 端口发现 / launchctl+ps / 中继探测全塞进登录路径（业主实测 7~8 秒）。
+        // 这里只回"保存成功 + bridge 重启结果 + 最小配置回显"，衍生信息由面板登录后异步拉
+        // （GET /dsh-remote/status & /bridge-status），UI 已经先切到已登录态。
+        const cfgEcho = loadConfig(relayDir);
+        sendJson(res, 200, {
+          ok: true,
+          bridgeRestart,
+          statusPending: true,
+          config: {
+            phone: maskPhone(cfgEcho.phone || ""),
+            hasPhone: Boolean(cfgEcho.phone),
+            hasPassword: Boolean(cfgEcho.password),
+            deviceId: cfgEcho.device_id || "",
+            apiUrl: cfgEcho.api_url || DEFAULT_API,
+            mode: cfgEcho.local_key ? "local" : "saas",
+            selfHostUrl: cfgEcho.tunnel_url ? String(cfgEcho.tunnel_url).replace(/^wss?:\/\//, "").replace(/\/+$/, "") : "",
+            hasLocalKey: Boolean(cfgEcho.local_key)
+          }
+        });
       },
     },
     {
@@ -9025,6 +9130,11 @@ export { pinBrowseDirectoryPicker as __pinBrowseDirectoryPicker, schedulePickerP
   setupStateOf as __setupStateOf, ensureConnection as __ensureConnection,
   // 设备超额锁定（契约 §8）：面板文案 / 插件半设备绑定退避都要能被单测钉住
   composeConnect as __composeConnect, readBindError as __readBindError, bindFailGate as __bindFailGate,
+  // B1（2026-11-07 登录慢）：端口发现是否阻塞、shell 探测 TTL 缓存、状态组装都要能被单测钉住
+  composeStatus as __composeStatus, launchdStatus as __launchdStatus,
+  clearStatusProbeCache as __clearStatusProbeCache, upstreamDiscoverySettled as __upstreamDiscoverySettled,
+  setUpstreamTestState as __setUpstreamTestState, resetUpstreamTestState as __resetUpstreamTestState,
+  STATUS_PROBE_TTL_MS as __STATUS_PROBE_TTL_MS,
   bindFailSignatureOf as __bindFailSignatureOf, isPermanentBindFailure as __isPermanentBindFailure,
   bindCapBackoffMs as __bindCapBackoffMs, connectBook as __connectBook, noteBindFailAttempt as __noteBindFailAttempt,
   DEVICE_BIND_CAP_EXIT_CODE as __DEVICE_BIND_CAP_EXIT_CODE, BIND_CAP_BACKOFF_MAX_MS as __BIND_CAP_BACKOFF_MAX_MS,

package/packages/dsh-remote-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.7.11-beta.3",
+  "version": "0.7.12-beta.1",
   "description": "公网远程控制 DeepSeek Harness（dsh web）：安装即得专属加密地址，人在外面也能用手机访问电脑上的 dsh——无需同一局域网/WiFi、无需公网 IP 与内网穿透，全程加密；手机端 100% 还原电脑体验（对话/工具/审批/设置）。技术用户可选自建服务，流量走自己的服务器。Remote control DeepSeek Harness (dsh web) from anywhere over the public internet — install, get an encrypted URL, use it from your phone on any network (dual-half cordis plugin: Settings panel + same-origin /dsh-remote routes). (2026-09 由 dsh-remote-ui 更名 / renamed from dsh-remote-ui; dsh-remote 的 dsh web 插件半，不是纯 UI/皮肤插件)",
   "type": "module",
   "main": "lib/index.js",

package/packages/dsh-remote-web/runtime/dsh-setup.mjs

@@ -2963,7 +2963,8 @@ function copyPluginIntoProfile(profileDir, pluginDir) {
  * 这里只认 dsh 自己那条解析路径能不能走通：
  *   ① 读得到 package.json 且 name 正确（cordis 加载器 + @deepseek-ai/dsh-client-modules 靠它读 dsh.client）；
  *   ② 读得到 lib/index.js（节点半入口）；
- *   ③ 要么 realpath 指回本地拷贝目录（链接形态），要么入口内容与本地拷贝逐字节一致（整目录拷贝形态）。
+ *   ③ 要么 realpath 指回本地拷贝目录（链接形态），要么**整目录拷贝**且
+ *      `lib/index.js` 与 `package.json` 都与本地拷贝逐字节一致（拷贝形态）。
  */
 function pluginLinkUsable(nmPlugin, pluginLocalDir) {
   try {
@@ -2977,9 +2978,23 @@ function pluginLinkUsable(nmPlugin, pluginLocalDir) {
   if (real) {
     try { if (real === fs.realpathSync(pluginLocalDir)) return true; } catch { /* 本地目录不在 → 看内容 */ }
   }
+  /**
+   * ★ 2026-11-07（桌面端实测）：拷贝形态**必须连 package.json 一起比对**，只看入口会漏掉旧版残留。
+   *
+   * 桌面 profile 用 pnpm `nodeLinker: hoisted`，`file:` 依赖会被**复制**进 profile 的
+   * `node_modules/<id>`（不是链接）。npx 安装器随后只替换了 `dsh-remote-web-plugin/`
+   * （file: 的源目录）—— 那份复制品还是上一版。而版本号只写在 package.json 里，
+   * 相邻 beta 之间的 `lib/index.js` 往往逐字节相同 ⇒ 旧判据判「已就绪」，
+   * 桌面端继续 import 旧的 package.json：面板版本号是旧的、`/self/update-check` 一直
+   * `outdated:true`，用户反复 npx 都"装不上新版"（实测 beta.3 → beta.10 复现）。
+   * 拷贝形态本就该与源目录完全一致，逐字节比对 package.json 即可识别，代价是一次 re-link。
+   */
   try {
-    return fs.readFileSync(path.join(nmPlugin, "lib", "index.js"), "utf8")
+    const sameEntry = fs.readFileSync(path.join(nmPlugin, "lib", "index.js"), "utf8")
       === fs.readFileSync(path.join(pluginLocalDir, "lib", "index.js"), "utf8");
+    if (!sameEntry) return false;
+    return fs.readFileSync(path.join(nmPlugin, "package.json"))
+      .equals(fs.readFileSync(path.join(pluginLocalDir, "package.json")));
   } catch { return false; }
 }
 

package/packages/dsh-remote-web/test/im-bots.test.mjs

@@ -357,3 +357,44 @@ test("PUT previewCardAt：非法值（非数字 / 0 / 负数）→ 400 invalid_p
     assert.equal(cfg.wecom.previewCardAt, 0, "非法触发值绝不能写进文件（桥会永久失效且难排查）");
   });
 });
+
+// ─────────────────── 会员档位 / 额度（2026-11-07 桥侧判定） ───────────────────
+
+test("GET：白名单透出 tier/caps/capsCount/bindingGated/messagesPerMonth/remainingMessages/usage", async () => {
+  const relayDir = await tmpRelay();
+  await withHost(relayDir, {}, async (base) => {
+    await writeStatus(relayDir, {
+      enabled: true, connected: true, tier: "free",
+      caps: ["wecom", "session_binding"], capsCount: 2, bindingGated: true,
+      messagesPerMonth: 20, remainingMessages: 7,
+      usage: { month: "2026-11", messages: 13 },
+      // 攻击面：状态文件里的内部字段/额外字段绝不能被整包吐出去
+      secret: "LEAK", capsRaw: { internal: "LEAK2" }, extra: "LEAK3",
+    });
+    const r = await json(`${base}/dsh-remote/im-bots`);
+    const st = r.body.status;
+    assert.equal(st.tier, "free");
+    assert.deepEqual(st.caps, ["wecom", "session_binding"], "caps 只取字符串数组（截断/过滤），不得透出对象");
+    assert.equal(st.capsCount, 2);
+    assert.equal(st.bindingGated, true);
+    assert.equal(st.messagesPerMonth, 20);
+    assert.equal(st.remainingMessages, 7);
+    assert.deepEqual(st.usage, { month: "2026-11", messages: 13 });
+    assert.ok(!JSON.stringify(r.body).includes("LEAK"), "★ 白名单之外的状态字段绝不能被透出");
+  });
+});
+
+test("GET：tier 只认三个枚举值；remainingMessages=null 表示不限/未知（不能被当成 0）", async () => {
+  const relayDir = await tmpRelay();
+  await withHost(relayDir, {}, async (base) => {
+    await writeStatus(relayDir, { tier: "gold", remainingMessages: null, messagesPerMonth: 0 });
+    let st = (await json(`${base}/dsh-remote/im-bots`)).body.status;
+    assert.equal(st.tier, "", "未知档位必须归一成空串（面板据此不渲染，绝不猜）");
+    assert.equal(st.remainingMessages, null, "null 必须保持 null（0 条剩余 ≠ 不限量）");
+    assert.equal(st.messagesPerMonth, 0);
+
+    await writeStatus(relayDir, { tier: "pro_max", remainingMessages: null });
+    st = (await json(`${base}/dsh-remote/im-bots`)).body.status;
+    assert.equal(st.tier, "pro_max");
+  });
+});

package/packages/dsh-remote-web/test/login-fast.test.mjs

@@ -0,0 +1,104 @@
+// 登录/首屏不再阻塞在「本机端口发现」上（2026-11-07 业主反馈：登录 7~8 秒太慢）。
+//
+// 根因定位（Lead）：登录后前端拉 /bridge-status 与 /account，服务端 composeConnect 里
+// `await discoverUpstreamSelf()`（lsof/netstat + 数百端口探测）+ launchctl/ps 全在响应路径上；
+// /config 还在响应里 `...(await composeStatus())`。
+//
+// 本文件锁三件事：
+//   ① composeConnect **不 await** 慢发现（<300ms 返回，并标记 discoveryPending）；
+//   ② POST /dsh-remote/config 立即返回（不带衍生状态，statusPending=true）；
+//   ③ shell 探测（launchctl/ps）走 10s TTL 缓存（避免每次轮询重跑）。
+import assert from "node:assert/strict";
+import http from "node:http";
+import { mkdtemp } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import {
+  apply,
+  __composeConnect as composeConnect,
+  __setUpstreamTestState as setUpstreamTestState,
+  __resetUpstreamTestState as resetUpstreamTestState,
+  __clearStatusProbeCache as clearStatusProbeCache,
+  __STATUS_PROBE_TTL_MS as STATUS_PROBE_TTL_MS,
+} from "../lib/index.js";
+
+// unref：模拟"慢发现"的定时器不能把测试进程空等到 5 秒（本套件对时长敏感）。
+const sleep = (ms) => new Promise((r) => { const t = setTimeout(r, ms); try { t.unref?.(); } catch { /* 忽略 */ } });
+const tmpRelay = () => mkdtemp(path.join(os.tmpdir(), "dsh-login-fast-"));
+
+test("composeConnect：端口发现再慢（5s）也不阻塞状态组装（<300ms），并标记 discoveryPending", async () => {
+  const relayDir = await tmpRelay();
+  setUpstreamTestState({ unsettled: true, discover: async () => { await sleep(5000); return "http://127.0.0.1:43210"; } });
+  clearStatusProbeCache();
+  try {
+    const t0 = Date.now();
+    const conn = await composeConnect(relayDir);
+    const cost = Date.now() - t0;
+    assert.ok(cost < 300, "★ composeConnect 必须 <300ms 返回（实测 " + cost + "ms）");
+    assert.equal(conn.discoveryPending, true, "端口发现还没完成时，必须如实标记 discoveryPending（面板可显示骨架）");
+    assert.ok(conn.phase, "状态阶段照常返回（不因发现未完成而缺字段）");
+  } finally {
+    resetUpstreamTestState();
+    clearStatusProbeCache();
+  }
+});
+
+test("composeConnect：发现已完成（缓存/hint）→ 不再触发发现、discoveryPending=false", async () => {
+  const relayDir = await tmpRelay();
+  setUpstreamTestState({ unsettled: false, discover: async () => { throw new Error("不该被调用"); } });
+  clearStatusProbeCache();
+  try {
+    const conn = await composeConnect(relayDir);
+    assert.equal(conn.discoveryPending, false, "发现已 settled 时不应标记 pending");
+  } finally {
+    resetUpstreamTestState();
+    clearStatusProbeCache();
+  }
+});
+
+test("POST /dsh-remote/config：立即返回（不 await 衍生状态），body.statusPending=true 且只回最小 config", async () => {
+  const relayDir = await tmpRelay();
+  setUpstreamTestState({ unsettled: true, discover: async () => { await sleep(5000); return "http://127.0.0.1:43210"; } });
+  const routes = [];
+  apply({
+    webServer: { register(rt) { routes.push(rt); return () => {}; } },
+    effect(reg) { return reg(); },
+    logger: { info() {}, warn() {} },
+  }, { relayDir });
+  const host = http.createServer((req, res) => {
+    const url = new URL(req.url, "http://x");
+    const rt = routes.find((r) => (r.kind === "prefix"
+      ? url.pathname === r.path || url.pathname.startsWith(r.path + "/")
+      : url.pathname === r.path));
+    (rt ? rt.handler : ((_r, rs) => { rs.writeHead(404); rs.end(); }))(req, res);
+  });
+  await new Promise((r) => host.listen(0, "127.0.0.1", r));
+  const base = `http://127.0.0.1:${host.address().port}`;
+  try {
+    const t0 = Date.now();
+    const r = await fetch(`${base}/dsh-remote/config`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ phone: "13800000000", password: "password123" }),
+    });
+    const cost = Date.now() - t0;
+    const body = await r.json();
+    assert.equal(r.status, 200);
+    assert.ok(cost < 300, "★ /config 必须 <300ms（实测 " + cost + "ms）—— 登录按钮的等待只该是登录请求本身");
+    assert.equal(body.ok, true);
+    assert.equal(body.statusPending, true, "★ 立即返回时必须声明 statusPending（前端据此异步补状态）");
+    assert.equal(typeof body.config, "object", "回最小配置回显（供 UI 立刻切换已登录态）");
+    assert.equal(body.config.hasPhone, true);
+    assert.equal("connect" in body, false, "★ 响应里不得再带衍生状态（connect/隧道/端口探测结果）");
+    assert.equal("service" in body, false, "★ 响应里不得再带 service 衍生信息");
+  } finally {
+    resetUpstreamTestState();
+    clearStatusProbeCache();
+    await new Promise((r) => host.close(r));
+  }
+});
+
+test("shell 探测 TTL：STATUS_PROBE_TTL_MS 是 10s 级短缓存（不是每次轮询都重跑 launchctl/ps）", () => {
+  assert.equal(STATUS_PROBE_TTL_MS, 10 * 1000, "缓存 TTL 必须是 10s（B1 约定）");
+});

package/packages/dsh-remote-web/test/login-selfheal-ui.test.mjs

@@ -227,7 +227,10 @@ test("未登录：不请求企业端、不出误导性红字；登录后自动
 
   assert.ok(!plugin.requests.some((r) => r.path === "/dsh-remote/access-key"), "未登录不得请求二维码接口");
   assert.ok(!plugin.requests.some((r) => r.path === "/dsh-remote/mobile-sessions"), "未登录不得请求设备列表");
-  assert.ok(textHas(tree, "登录下方「🔑 账号」卡片中的手机号账号后"), "未登录应给登录引导而非报错");
+  // IA 重做（2026-11-07）：未登录点「打开手机端/生成访问码」→ 直接弹登录弹层并说明原因；
+  // 这张卡自己的按钮文案也写明「登录并生成访问码」（不再静默失败）。
+  assert.ok(textHas(tree, "登录并生成访问码") || textHas(tree, "登录后才能用手机访问"),
+    "未登录应给明确的登录引导（不是静默失败，也不是红字报错）");
   assert.ok(!textHas(tree, "尚未登录"), "未登录也不该出现接口报错红字");
 
   tree = await plugin.login();

package/packages/dsh-remote-web/test/panel-ia.test.mjs

@@ -75,6 +75,12 @@ function domIndex(tree, predicate) {
 }
 const flush = () => new Promise((resolve) => setImmediate(resolve));
 
+/** 收集所有匹配节点（用例里要数"有几个单选"这类）。 */
+function findAll(tree, predicate) {
+  const out = [];
+  walk(tree, (n) => { if (predicate(n)) out.push(n); });
+  return out;
+}
 /** 子树全部文本（拼接；用于"卡片文案/按钮文案"断言）。 */
 function textOf(node) {
   let out = "";
@@ -92,6 +98,7 @@ function loadPlugin(opts = {}) {
   const metas = [];
   const injects = new Map();
   const requests = [];
+  const clipboard = [];
   let unmounted = false;
 
   // ── 迷你 React：真实 useState/useEffect + 递归展开**函数子组件** ──
@@ -223,7 +230,7 @@ function loadPlugin(opts = {}) {
     document: doc,
     localStorage,
     MutationObserver: MutationObserverMock,
-    navigator: { clipboard: { writeText: async () => {} } },
+    navigator: { clipboard: { writeText: async (t) => { clipboard.push(String(t)); } } },
     setTimeout: fakeSetTimeout,
     clearTimeout: fakeClear,
     setInterval: fakeSetInterval,
@@ -299,7 +306,7 @@ function loadPlugin(opts = {}) {
   }
 
   return {
-    requests, metas, injects,
+    requests, metas, injects, clipboard,
     counts() { return { ...counts }; },
     /** 设置页栏目列表（模拟 shell 的 ctx.slots.entries("settings.section")，按 order 排序）。 */
     sectionList() { return metas.filter((m) => m.name === "settings.section").slice().sort((a, b) => a.order - b.order); },
@@ -796,3 +803,194 @@ test("发送预览卡片：已绑定（boundChatId 非空）→ 不显示未绑
   assert.ok(!textOf(tree).includes("先在企微里给机器人发一句话完成绑定"), "已绑定就不该再提示未绑定");
   assert.ok(textOf(tree).includes("上次预览：09:07"), "应显示上次预览时间（HH:MM）");
 });
+
+// ───────────── ⑨ 未登录守卫 + 后台服务横排 + 卸载挽留（2026-11-07 业主逐条）─────────────
+
+test("未登录「手机访问」卡：文案写「登录并生成访问码」，点击弹登录弹层；登录成功后自动回到手机访问", async () => {
+  const plugin = loadPlugin();
+  plugin.setSignedIn(false);
+  let tree = await plugin.settle();
+  const card = find(tree, (n) => String(n.props?.className || "").includes("dru-ia-card")
+    && textOf(n).includes("手机访问"));
+  assert.ok(card, "入口网格里应有「手机访问」卡");
+  assert.ok(textOf(card).includes("登录并生成访问码"), "未登录时按钮文案必须是「登录并生成访问码」（不是静默失败）");
+  const btn = find(card, (n) => n.type === "button");
+  btn.props.onClick();
+  tree = await plugin.settle();
+  assert.ok(textOf(tree).includes("登录后才能用手机访问"), "点击后弹登录弹层并说明原因");
+
+  // 登录成功 → 自动回到「手机访问」流程（iaAfterLogin 回跳），不再让用户自己再找一遍
+  plugin.setSignedIn(true);
+  tree = await plugin.settle(4);
+  assert.ok(textOf(tree).includes("手机访问"), "登录后应回到手机访问流程");
+  const dlg = find(tree, (n) => String(n.props?.className || "").split(/\s+/).includes("dru-ia-dialog"));
+  assert.ok(dlg, "登录后应自动打开手机访问弹层");
+});
+
+test("后台服务区块（A6）：显眼提示 + 横向紧凑网格（状态/启停/自启动/设备ID 不再竖排占屏）", async () => {
+  const plugin = loadPlugin();
+  const tree = await plugin.settle();
+  assert.ok(textOf(tree).includes("保持在线，才能用手机端远程控制这台电脑"), "必须有「保持在线」提示（业主点名）");
+  const grid = find(tree, (n) => String(n.props?.className || "") === "dru-bridge-grid");
+  assert.ok(grid, "后台服务应为横向网格布局（.dru-bridge-grid）");
+  const cells = byClass(grid, "dru-bridge-cell");
+  assert.ok(cells.length >= 4, "网格应含 4 格：状态 / 启停 / 自启动 / 设备 ID，实际 " + cells.length);
+  assert.ok(cells.some((c) => textOf(c).includes("设备 ID")), "设备 ID 在网格里（横向）");
+});
+
+test("彻底卸载（A7）：先弹挽留反馈（原因单选 + 建议）→ 提交走现有反馈通道 → 才继续卸载", async () => {
+  const plugin = loadPlugin();
+  let tree = await plugin.settle();
+  const unBtn = btnWith(tree, "彻底卸载");
+  assert.ok(unBtn, "应有「彻底卸载」按钮");
+  unBtn.props.onClick();
+  tree = await plugin.settle();
+  const dlg = find(tree, (n) => String(n.props?.className || "").split(/\s+/).includes("dru-ia-dialog"));
+  assert.ok(dlg, "点彻底卸载应先弹挽留反馈弹层");
+  assert.ok(textOf(dlg).includes("为什么要卸载"), "弹层要问「为什么要卸载？」；实际=" + textOf(dlg).slice(0, 200));
+  const radios = findAll(dlg, (n) => n.type === "input" && n.props?.type === "radio");
+  assert.ok(radios.length >= 4, "应有多个原因单选，实际 " + radios.length);
+  assert.ok(find(dlg, (n) => n.type === "textarea"), "应有可填建议的输入框");
+  assert.ok(btnWith(dlg, "我再想想"), "必须有「我再想想」退出选项");
+  // 未选原因就点「仍要卸载」→ 就近报错，且不提交/不卸载
+  const before = plugin.requests.length;
+  btnWith(dlg, "仍要卸载").props.onClick();
+  tree = await plugin.settle();
+  assert.ok(textOf(tree).includes("请选择一个卸载原因"), "未选原因要给就近错误");
+  const after = plugin.requests.slice(before).map((r) => r.path);
+  assert.ok(!after.includes("/dsh-remote/feedback"), "未选原因不得提交反馈（" + after.join(",") + "）");
+  assert.ok(!after.includes("/dsh-remote/self/uninstall"), "未选原因更不得开始卸载");
+
+  // 选一个原因 + 写建议 → 仍要卸载：先 POST 反馈（kind=uninstall），再 POST 卸载
+  const r0 = findAll(tree, (n) => n.type === "input" && n.props?.type === "radio")[0];
+  r0.props.onChange({ target: { value: r0.props.value } });
+  tree = await plugin.settle();
+  const note = find(tree, (n) => n.type === "textarea");
+  note.props.onChange({ target: { value: "加载太慢，希望优化" } });
+  tree = await plugin.settle();
+  btnWith(tree, "仍要卸载").props.onClick();
+  await flush(); await flush(); await flush();
+  const fb = plugin.requests.find((r) => r.path === "/dsh-remote/feedback" && r.method === "POST");
+  assert.ok(fb, "★ 必须先提交挽留反馈（复用现有反馈通道，不新增后端）");
+  assert.equal(fb.body.kind, "uninstall", "反馈必须带 kind=uninstall 标记");
+  assert.ok(String(fb.body.content).includes("原因"), "反馈内容要含所选原因");
+  assert.ok(String(fb.body.content).includes("加载太慢"), "用户填的建议要带上");
+  assert.ok(plugin.requests.some((r) => r.path === "/dsh-remote/self/uninstall" && r.method === "POST"),
+    "★ 提交反馈后应继续执行卸载（反馈不能反过来卡住用户）");
+});
+
+// ───────────────────── ⑩ 会员档位条 + 会话固定门禁（2026-11-07 桥侧判定） ─────────────────────
+
+test("企微配置页档位条：免费档 → 「本月剩余 N 条指令（每月 20 条）」+ 「升级 Pro 不限量」链接", async () => {
+  const plugin = loadPlugin();
+  plugin.setImBotsGet({
+    ok: true,
+    wecom: { enabled: true, botId: "aibdemo1234", hasSecret: true, url: "", targetChatId: "", sessionId: "", sessionTitle: "" },
+    status: {
+      connected: true, authenticated: true, tier: "free",
+      messagesPerMonth: 20, remainingMessages: 7, usage: { month: "2026-11", messages: 13 },
+      bindingGated: false, caps: ["wecom"], capsCount: 1,
+      sessions: [], activeSessionId: "", boundSessionId: "",
+    },
+  });
+  const tree = await openWecom(plugin);
+  const tierBar = find(tree, (n) => String(n.props?.className || "").includes("dru-ia-tier"));
+  assert.ok(tierBar, "免费档应渲染档位条");
+  assert.ok(textOf(tierBar).includes("免费档"), "档位条要写明「免费档」");
+  assert.ok(textOf(tierBar).includes("本月剩余 7 条指令"), "要显示剩余指令数");
+  assert.ok(textOf(tierBar).includes("每月 20 条"), "要显示每月上限");
+  const link = find(tierBar, (n) => n.type === "a");
+  assert.ok(link, "免费档必须有升级入口");
+  assert.equal(link.props.href, "/app/promo", "升级链接指向 /app/promo");
+  assert.ok((link.children || []).join("").includes("升级 Pro 不限量"));
+});
+
+test("企微配置页档位条：pro / pro_max → 「会员档 · 指令不限」，不出现升级链接", async () => {
+  for (const tier of ["pro", "pro_max"]) {
+    const plugin = loadPlugin();
+    plugin.setImBotsGet({
+      ok: true,
+      wecom: { enabled: true, botId: "aibdemo1234", hasSecret: true, url: "", targetChatId: "", sessionId: "", sessionTitle: "" },
+      status: { connected: true, authenticated: true, tier, bindingGated: false, sessions: [], activeSessionId: "", boundSessionId: "" },
+    });
+    const tree = await openWecom(plugin);
+    const tierBar = find(tree, (n) => String(n.props?.className || "").includes("dru-ia-tier"));
+    assert.ok(tierBar, tier + " 应渲染档位条");
+    assert.ok(textOf(tierBar).includes("会员档 · 指令不限"), tier + " 文案应为「会员档 · 指令不限」");
+    assert.equal(find(tierBar, (n) => n.type === "a"), undefined, tier + " 会员档不该有升级链接");
+  }
+});
+
+test("企微配置页档位条：取不到 tier / 未知值 → 整行不渲染（绝不瞎猜）", async () => {
+  for (const status of [
+    { connected: true, sessions: [], activeSessionId: "", boundSessionId: "" },                 // 旧桥：没有 tier
+    { connected: true, tier: "gold", sessions: [], activeSessionId: "", boundSessionId: "" },    // 未知值
+  ]) {
+    const plugin = loadPlugin();
+    plugin.setImBotsGet({
+      ok: true,
+      wecom: { enabled: false, botId: "", hasSecret: false, url: "", targetChatId: "", sessionId: "", sessionTitle: "" },
+      status,
+    });
+    const tree = await openWecom(plugin);
+    assert.equal(find(tree, (n) => String(n.props?.className || "").includes("dru-ia-tier")), undefined,
+      "拿不到有效档位时不得渲染档位条（" + JSON.stringify(status.tier) + "）");
+  }
+});
+
+test("会话固定门禁：bindingGated=true → 下拉置灰 + 「会员功能」徽章 + 悬停说明；已选值被忽略时如实说明", async () => {
+  const plugin = loadPlugin();
+  plugin.setImBotsGet({
+    ok: true,
+    wecom: { enabled: true, botId: "aibdemo1234", hasSecret: true, url: "", targetChatId: "", sessionId: "sess-1-abcdef123456", sessionTitle: "修复登录问题" },
+    status: {
+      connected: true, authenticated: true, tier: "free", bindingGated: true,
+      sessions: [{ id: "sess-1-abcdef123456", title: "修复登录问题", updatedAt: 1 }],
+      activeSessionId: "sess-2-xyz", activeSessionTitle: "部署到 NAS", boundSessionId: "",
+    },
+  });
+  const tree = await openWecom(plugin);
+  const sel = find(tree, (n) => n.type === "select" && n.props?.id === "dru-wecom-session");
+  assert.ok(sel, "下拉仍应存在（只是置灰）");
+  assert.equal(sel.props.disabled, true, "★ 免费档必须置灰（不能假装能选）");
+  assert.equal(sel.props.title, "升级后可固定转接会话", "悬停必须说明为什么不能选");
+  assert.equal(sel.props.value, "", "被忽略的选择不能显示成生效值");
+  const badge = find(tree, (n) => String(n.props?.className || "").includes("dru-ia-badge"));
+  assert.ok(badge && textOf(badge).includes("会员功能"), "置灰处要有「会员功能」徽章");
+  assert.ok(textOf(tree).includes("当前跟随活跃会话"), "已选值被忽略时要显示「当前跟随活跃会话」");
+  assert.ok(textOf(tree).includes("免费档不能固定转接"), "小字要说明原因");
+});
+
+// ───────────────────── ⑪ 品牌全名 + 安装命令（2026-11-07 业主） ─────────────────────
+
+test("品牌：面板标题 / 关于卡片统一用全名 dsh-remote-web，旧的「关于 dsh-remote」不再出现", async () => {
+  const plugin = loadPlugin();
+  const tree = await plugin.settle();
+  // 顶部面板标题（业主：「我的插件名字叫 dsh-remote-web，这个是全名」）
+  const title = find(tree, (n) => String(n.props?.className || "").includes("dru-settings-title"));
+  assert.ok(title, "应有面板标题");
+  assert.equal((title.children || []).join(""), "dsh-remote-web", "顶部标题必须是品牌全名 dsh-remote-web");
+  // 关于卡片
+  assert.ok(textOf(tree).includes("关于 dsh-remote-web"), "关于段落标题应为「关于 dsh-remote-web」");
+  // 精确断言：不得再出现裸品牌「关于 dsh-remote」（但不能误伤包名 @mrrisega/dsh-remote）
+  assert.doesNotMatch(SOURCE, /关于 dsh-remote(?!-web)/, "旧品牌写法「关于 dsh-remote」不得再出现");
+  assert.match(SOURCE, /@mrrisega\/dsh-remote/, "包名 @mrrisega/dsh-remote 必须保留（不是品牌文案）");
+  assert.match(SOURCE, /~\/\.dsh-remote/, "配置目录 ~/.dsh-remote 必须保留（代码/数据路径，不是品牌文案）");
+});
+
+test("版本与更新：有一行可复制的安装/更新命令 npx @mrrisega/dsh-remote@latest + 「重跑这条命令即可」说明", async () => {
+  const plugin = loadPlugin();
+  let tree = await plugin.settle();
+  assert.ok(textOf(tree).includes("npx @mrrisega/dsh-remote@latest"), "版本卡必须给出安装/更新命令");
+  assert.ok(textOf(tree).includes("已安装的更新：重跑这条命令即可"), "要说明更新方式是重跑该命令");
+  const copyBtn = find(tree, (n) => n.type === "button" && n.props?.["aria-label"] === "复制安装命令");
+  assert.ok(copyBtn, "命令旁必须有复制按钮（复用现有复制反馈样式）");
+  const code = find(tree, (n) => String(n.props?.className || "").includes("dru-code-val"));
+  assert.ok(code && (code.children || []).join("").includes("@mrrisega/dsh-remote@latest"), "命令要以可复制的代码样式展示");
+
+  copyBtn.props.onClick();
+  await flush(); await flush();
+  assert.deepEqual(plugin.clipboard, ["npx @mrrisega/dsh-remote@latest"], "★ 点复制必须把安装命令写进剪贴板");
+  tree = await plugin.settle();
+  assert.ok(textOf(tree).includes("✅ 已复制"), "复制成功要有与其它复制按钮一致的反馈");
+});