@mrrisega/dsh-remote 0.6.0 → 0.6.1-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.6.0",
+  "version": "0.6.1-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",
@@ -52,7 +52,9 @@
     "test:router": "node --test packages/relay-router/test/native-device-selection.test.mjs packages/relay-router/test/quotas.test.mjs",
     "test:plugin": "node --test --test-concurrency=1 packages/dsh-remote-web/test/*.test.mjs",
     "test:bridge": "node --test clients/dsh-remote/test/*.test.mjs",
-    "check": "node --check clients/dsh-remote/dsh-bridge.mjs && node --check clients/dsh-remote/e2ee-shim.mjs && node --check dsh-setup.mjs && node --check packages/dsh-remote-web/lib/index.js && node --check packages/dsh-remote-web/lib/client.js && bash -n deploy/install-open.sh"
+    "check": "node --check clients/dsh-remote/dsh-bridge.mjs && node --check clients/dsh-remote/e2ee-shim.mjs && node --check dsh-setup.mjs && node --check packages/dsh-remote-web/lib/index.js && node --check packages/dsh-remote-web/lib/client.js && bash -n deploy/install-open.sh && npm run check:alias",
+    "sync:alias": "node scripts/sync-legacy-alias.mjs",
+    "check:alias": "node scripts/sync-legacy-alias.mjs --check"
   },
   "dependencies": {
     "ws": "^8.18.0"

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

@@ -347,6 +347,42 @@ window.__ModuleLoader__.load({
       return api(path, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(data || {}) });
     };
 
+    // ── 登录后首次加载的自愈（0.6.1-beta.1） ───────────────────────────────
+    // 现象（首次安装后立即登录）：面板在 loggedIn 翻真的瞬间就请求 /dsh-remote/access-key 与
+    // /dsh-remote/mobile-sessions；此时中继握手可能尚未就绪（bridge 刚被重启、device-login 共享密钥
+    // 刚补齐或正在轮换、中继冷启动/网络抖动），旧版只报一次红字且不重试——必须手动刷新页面才行。
+    // 现在：可重试类失败按退避自动重试（成功即自动清除红字），并给红字配「重试」按钮。
+    var LOGIN_LOAD_RETRY_MS = [1200, 3000, 6000];
+
+    /** node 半标记 retryable（中继未就绪）或网络/5xx → 值得自动重试；未登录/密码失效不重试。 */
+    function retryableFail(e) {
+      var body = e && e.body;
+      if (body && body.retryable === true) return true;
+      if (body && typeof body.hint === "string" && /^relay_/.test(body.hint)) return true;
+      var st = e && e.status;
+      if (typeof st !== "number") return true;       // fetch 本身失败（网络中断/被中止）
+      return st === 0 || st === 408 || st === 429 || st >= 500;
+    }
+
+    /** 定时器节流：tests/SSR 环境没有 setTimeout 时静默降级（不抛错、不阻塞面板）。 */
+    function later(fn, ms) {
+      try { return setTimeout(fn, ms); } catch (e) { return null; }
+    }
+    function clearLater(t) {
+      if (t == null) return;
+      try { clearTimeout(t); } catch (e) { /* 忽略 */ }
+    }
+
+    /** 一次性访问密钥 / 已授权设备列表的自动重试状态（放在组件外：不随渲染重建）。 */
+    var akeyRetry = { timer: null, attempt: 0 };
+    var devRetry = { timer: null, attempt: 0 };
+    // 请求在途标记同样放组件外：组件内 state 闭包会在定时器/轮询回调里过期，
+    // 导致 busy 护栏失效（重复请求）或误拦（该重试却跳过）。
+    var akeyInFlight = { v: false };
+    var devInFlight = { v: false };
+    function cancelAkeyRetry() { clearLater(akeyRetry.timer); akeyRetry.timer = null; }
+    function cancelDevRetry() { clearLater(devRetry.timer); devRetry.timer = null; }
+
     /** 一次性访问 url → 升级/续费页 url（带同一 auth，进入后即登录态到 /app/promo）。 */
     function promoUrlOf(u) {
       var s = String(u || "");
@@ -1126,6 +1162,8 @@ window.__ModuleLoader__.load({
 
       var loggedIn = !!(st && st.config && (st.config.phone || st.config.hasLocalKey));
       var serviceRunning = !!(st && st.service && st.service.running);
+      // 账号标识（掩码手机号）：登录成功/换账号时变化 → 触发上方的重取 effect（比布尔 loggedIn 更敏感）
+      var phoneKey = (st && st.config && st.config.phone) || "";
       var launchdPid = st && st.service && st.service.launchd && st.service.launchd.pid;
 
       // 已登录(SaaS)→ 拉我的信息/配额/公共配置
@@ -1184,20 +1222,26 @@ window.__ModuleLoader__.load({
         return d.getFullYear() + "-" + pad2(d.getMonth() + 1) + "-" + pad2(d.getDate()) + " " + pad2(d.getHours()) + ":" + pad2(d.getMinutes());
       }
 
-      /** 创建（或刷新）一次性访问密钥：GET /dsh-remote/access-key（node 半转发企业端 /api/auth-key）。 */
+      /**
+       * 创建（或刷新）一次性访问密钥：GET /dsh-remote/access-key（node 半转发企业端 /api/auth-key）。
+       * 失败自愈：中继未就绪类失败（node 半 retryable / 网络 / 5xx）按退避自动重试，
+       * 见「登录后首次加载自愈」——首次安装立即登录时不再需要手动刷新页面。
+       */
       function loadAccessKey() {
-        if (akeyBusy) return;
+        if (akeyInFlight.v) return;
         // 登录前不请求企业端（避免 401/404 噪音）；由账号登录成功后触发
         if (!(st && st.config && st.config.phone)) {
           setAkeyMsg(null);
+          cancelAkeyRetry();
           return;
         }
+        akeyInFlight.v = true;
         setAkeyBusy(true);
         api("/dsh-remote/access-key").then(function (b) {
           if (!b || !b.ok) {
             var why = (b && (b.error || (b.body && b.body.error))) || "未知错误";
-            setAkeyMsg({ kind: "err", text: "获取一次性访问地址失败：" + why });
-            return;
+            var e = new Error(why); e.body = b || null;
+            throw e;
           }
           // 契约容错：url 必须有；qr_data_url 取不到时仍展示链接/复制/直接打开
           if (!b.url) {
@@ -1212,9 +1256,16 @@ window.__ModuleLoader__.load({
             qr_data_url: b.qr_data_url != null ? b.qr_data_url : null
           });
           setAkeyMsg(null);
+          akeyRetry.attempt = 0;
         }).catch(function (e) {
-          setAkeyMsg({ kind: "err", text: "获取一次性访问地址失败：" + e.message });
-        }).finally(function () { setAkeyBusy(false); });
+          var text = "获取一次性访问地址失败：" + e.message;
+          if (retryableFail(e) && akeyRetry.attempt < LOGIN_LOAD_RETRY_MS.length) {
+            scheduleAkeyRetry(text);
+            return;
+          }
+          // 自动重试额度用尽（或不该重试）→ 红字 + 「立即重试」入口，不让用户只能刷新页面
+          setAkeyMsg({ kind: "err", text: text, retry: retryAkeyManually });
+        }).finally(function () { akeyInFlight.v = false; setAkeyBusy(false); });
       }
 
       var copyKeyUrl = function () {
@@ -1232,17 +1283,67 @@ window.__ModuleLoader__.load({
         try { window.open(akey.url, "_blank", "noopener"); } catch (e) {}
       };
 
-      /** 加载已授权设备列表：GET /dsh-remote/mobile-sessions。 */
+      /** 加载已授权设备列表：GET /dsh-remote/mobile-sessions（失败同上：可重试类自动重试）。 */
       function loadDevices() {
-        if (devBusy !== "") return;
+        if (devInFlight.v || devBusy !== "") return;
+        devInFlight.v = true;
         setDevBusy("list");
         api("/dsh-remote/mobile-sessions").then(function (b) {
           if (!b || !b.ok) throw new Error((b && b.error) || "加载已授权设备失败");
           setDevSessions(Array.isArray(b.sessions) ? b.sessions : []);
           setDevMsg(null);
+          devRetry.attempt = 0;
         }).catch(function (e) {
-          setDevMsg({ kind: "err", text: "加载已授权设备失败：" + e.message });
-        }).finally(function () { setDevBusy(""); });
+          var text = "加载已授权设备失败：" + e.message;
+          if (retryableFail(e) && devRetry.attempt < LOGIN_LOAD_RETRY_MS.length) {
+            scheduleDevRetry(text);
+            return;
+          }
+          setDevMsg({ kind: "err", text: text, retry: retryDevicesManually });
+        }).finally(function () { devInFlight.v = false; setDevBusy(""); });
+      }
+      /** 手动重试（红字旁的「重试」按钮）：重置退避计数后立即重新拉取。 */
+      var retryAkeyManually = function () {
+        cancelAkeyRetry();
+        akeyRetry.attempt = 0;
+        setAkeyMsg(null);
+        loadAccessKey();
+      };
+      var retryDevicesManually = function () {
+        cancelDevRetry();
+        devRetry.attempt = 0;
+        setDevMsg(null);
+        loadDevices();
+      };
+      /** 定时重试一次性访问密钥（黄字提示 + 退避；成功时由 loadAccessKey 清掉提示）。 */
+      function scheduleAkeyRetry(why) {
+        cancelAkeyRetry();
+        var wait = LOGIN_LOAD_RETRY_MS[akeyRetry.attempt] || LOGIN_LOAD_RETRY_MS[LOGIN_LOAD_RETRY_MS.length - 1];
+        akeyRetry.attempt += 1;
+        setAkeyMsg({
+          kind: "warn",
+          text: "中继连接尚未就绪，" + Math.round(wait / 1000) + " 秒后自动重试（第 " + akeyRetry.attempt + "/" + LOGIN_LOAD_RETRY_MS.length + " 次）：" + why,
+          retry: retryAkeyManually
+        });
+        akeyRetry.timer = later(function () {
+          akeyRetry.timer = null;
+          loadAccessKey(); // 在途标记由上一个请求的 finally 释放，退避窗口内用户也可手动刷新
+        }, wait);
+      }
+      /** 定时重试已授权设备列表（同上）。 */
+      function scheduleDevRetry(why) {
+        cancelDevRetry();
+        var wait = LOGIN_LOAD_RETRY_MS[devRetry.attempt] || LOGIN_LOAD_RETRY_MS[LOGIN_LOAD_RETRY_MS.length - 1];
+        devRetry.attempt += 1;
+        setDevMsg({
+          kind: "warn",
+          text: "中继连接尚未就绪，" + Math.round(wait / 1000) + " 秒后自动重试（第 " + devRetry.attempt + "/" + LOGIN_LOAD_RETRY_MS.length + " 次）：" + why,
+          retry: retryDevicesManually
+        });
+        devRetry.timer = later(function () {
+          devRetry.timer = null;
+          loadDevices();
+        }, wait);
       }
       /** 操作（取消配对/删除记录/清理已解绑）成功后静默重拉列表，覆盖行内状态。 */
       function refreshDeviceList() {
@@ -1346,13 +1447,22 @@ window.__ModuleLoader__.load({
 
       // 已登录云端主视图停留期间：打开即取一把新 key + 已授权设备；之后每 ~25s 自动轮换
       // （未登录不轮询，避免 401 空转；离开栏目/切视图/退出登录即清理定时器）
+      //
+      // 依赖里带上「账号」与「bridge 运行态」：登录成功（含换账号）与 bridge 拉起/重启后立即重取，
+      // 首次安装后立即登录不再需要手动刷新页面；失败重试由 loadAccessKey/loadDevices 内部退避处理。
       useEffect(function () {
         if (view !== "home" || mode !== "saas" || !loggedIn) return undefined;
+        cancelAkeyRetry(); cancelDevRetry();
+        akeyRetry.attempt = 0; devRetry.attempt = 0;
         loadAccessKey();
         loadDevices();
         var rotateIv = setInterval(function () { loadAccessKey(); }, KEY_AUTO_REFRESH_MS);
-        return function () { clearInterval(rotateIv); };
-      }, [view, mode, loggedIn]);
+        return function () {
+          clearInterval(rotateIv);
+          cancelAkeyRetry();
+          cancelDevRetry();
+        };
+      }, [view, mode, loggedIn, phoneKey, serviceRunning]);
 
       function setMsg(kind, text) { setMessage({ kind: kind, text: text }); }
 
@@ -1760,7 +1870,13 @@ window.__ModuleLoader__.load({
             h("span", null, statusTxt)
           ),
           renderE2eeBadge(),
-          akeyMsg ? h("div", { className: "dru-msg dru-msg-" + akeyMsg.kind, style: { marginTop: 8 } }, akeyMsg.text) : null,
+          akeyMsg
+            ? h("div", { className: "dru-msg dru-msg-" + akeyMsg.kind, style: { marginTop: 8 } },
+                akeyMsg.text,
+                akeyMsg.retry
+                  ? h("button", { type: "button", className: "dru-linkbtn", style: { marginLeft: 8 }, disabled: akeyBusy, onClick: akeyMsg.retry }, akeyBusy ? "重试中…" : "立即重试")
+                  : null)
+            : null,
           hasKey ? h("div", null, [
             h("div", { className: "dru-url big", style: { marginTop: 8 } },
               h("span", null, akey.url),
@@ -1883,7 +1999,13 @@ window.__ModuleLoader__.load({
             }, devBusy === "list" ? "加载中…" : btnLabel)
           ),
           devOpen ? renderDeviceList() : null,
-          devMsg ? h("div", { className: "dru-msg dru-msg-" + devMsg.kind, style: { marginTop: 6 } }, devMsg.text) : null
+          devMsg
+            ? h("div", { className: "dru-msg dru-msg-" + devMsg.kind, style: { marginTop: 6 } },
+                devMsg.text,
+                devMsg.retry
+                  ? h("button", { type: "button", className: "dru-linkbtn", style: { marginLeft: 8 }, disabled: devBusy !== "", onClick: devMsg.retry }, devBusy === "list" ? "重试中…" : "立即重试")
+                  : null)
+            : null
         ]);
       }
 

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

@@ -612,15 +612,135 @@ async function relayFetch(relayDir, pathname, init) {
   }
 }
 
-// ---------- v2 账号/配额/邀请代理（我的信息 与 免费额度提示） ----------
+// ---------- bridge_secret 自愈（device-login 共享密钥） ----------
 
-/** 获取短期 relay token:SaaS → device-login;本地模式 → /_login(从隧道地址推导同源)。 */
-async function relayToken(relayDir) {
-  const cfg = loadConfig(relayDir);
+/**
+ * 企业端 POST /api/device-login 强制校验 `x-dsh-bridge-secret`（缺失/失效 → 401 "需要有效设备密钥"），
+ * 密钥由服务端公开配置 /api/public-config 下发、与 dsh-setup.mjs 的 `bridge_secret` 同源。
+ *
+ * 一键安装器（npx @mrrisega/dsh-remote → dsh-setup.mjs）会在安装时取一次并写入 .dsh-config.json；
+ * 但**只装插件**的路径（dsh plugin add / 插件市场安装）没有这一步，于是：
+ *   首次安装 → 打开设置面板立即登录 → 面板请求 /dsh-remote/access-key & mobile-sessions
+ *   → relayToken 拿不到 token（401 需要设备密钥）→ 面板显示「尚未登录」（其实是密钥缺失）
+ * 直到后台自愈（scheduleRuntime → ensureRuntime 跑一次 npx 安装器）把 bridge_secret 写回配置，
+ * 或用户手动刷新页面才恢复——这正是「首次安装后立即登录，二维码/设备列表报红字」的根因。
+ *
+ * 这里在插件侧补上同一份自愈：缺密钥就取一次、落盘并缓存；失败短退避后可再试，不阻塞面板。
+ */
+let bridgeSecretCache = { dir: "", secret: "", failedAt: 0 };
+const BRIDGE_SECRET_RETRY_MS = 15_000;
+
+/** 读取配置里已保存的 bridge_secret（无则空串）。 */
+function readBridgeSecret(relayDir) {
+  try {
+    return String(loadConfig(relayDir).bridge_secret || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * 取 device-login 共享密钥：配置已有 → 直接用；否则向企业端公开配置取一次并写回配置（内存缓存兜底）。
+ * @param {string} relayDir 配置目录
+ * @param {object} [cfgOverride] 尚未落盘的配置（登录请求刚写入 phone/password 时用），仅用于判断模式
+ * @param {{force?: boolean, timeoutMs?: number}} [opts] force=true 跳过本地文件/缓存强制重取；
+ *        timeoutMs 限制单次公开配置请求耗时（登录路径用更短的上限，避免拖慢登录响应）
+ * @returns {Promise<string>} 密钥（取不到为空串，调用方按“中继未就绪”降级，不抛错）
+ */
+async function bridgeSecretOf(relayDir, cfgOverride, opts) {
+  const force = !!(opts && opts.force);
+  if (!force) {
+    const local = readBridgeSecret(relayDir);
+    if (local) {
+      bridgeSecretCache = { dir: relayDir, secret: local, failedAt: 0 };
+      return local;
+    }
+    if (bridgeSecretCache.dir === relayDir && bridgeSecretCache.secret) return bridgeSecretCache.secret;
+    if (bridgeSecretCache.dir === relayDir && Date.now() - bridgeSecretCache.failedAt < BRIDGE_SECRET_RETRY_MS) return ""; // 负缓存：别把公开配置打爆
+  }
+  const cfg = cfgOverride && typeof cfgOverride === "object" ? { ...loadConfig(relayDir), ...cfgOverride } : loadConfig(relayDir);
+  if (cfg.local_key) return ""; // 自建模式走 /_login，不用设备密钥
   const api = (cfg.api_url || DEFAULT_API).replace(/\/+$/, "");
-  if (cfg.local_key) {
-    // 本地认证:POST {tunnel 同源}/_login
-    const u = new URL(cfg.tunnel_url || api.replace(/^https?/, "wss"));
+  const timeoutMs = Number((opts && opts.timeoutMs) || 0) > 0 ? Number(opts.timeoutMs) : 6000;
+  let secret = "";
+  try {
+    const r = await fetch(`${api}/api/public-config`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (r.ok) {
+      const d = await r.json();
+      secret = String((d && d.bridge_secret) || "").trim();
+    }
+  } catch { /* 网络抖动：负缓存短退避后再试 */ }
+  if (!secret) {
+    bridgeSecretCache = { dir: relayDir, secret: "", failedAt: Date.now() };
+    return "";
+  }
+  bridgeSecretCache = { dir: relayDir, secret, failedAt: 0 };
+  // 落盘（与 dsh-setup.mjs 同一份配置）：即使本进程退出，下次启动也不再缺密钥/不再是旧密钥
+  let healed = false;
+  try {
+    const cur = loadConfig(relayDir);
+    if (!cur.bridge_secret || (force && cur.bridge_secret !== secret)) {
+      cur.bridge_secret = secret;
+      saveConfig(relayDir, cur);
+      healed = true;
+    }
+  } catch { /* 写盘失败不致命：内存缓存本次进程内仍生效 */ }
+  // 密钥是「从无到有」补上的：已经在跑的 bridge 是用空密钥起的，隧道认证同样会失败——
+  // 后台重启一次让它带上密钥（一次性事件，失败只记日志不打断面板请求）。
+  if (healed && !UNINSTALLED_DIRS.has(relayDir)) {
+    setTimeout(() => {
+      try {
+        const st = launchdStatus();
+        if (!st.running) return;
+        const r = startBridge(relayDir);
+        console.log(`[dsh-remote-web] 已补记 bridge_secret，后台重启 bridge 使其生效: ${r.status}`);
+      } catch (e) {
+        console.warn(`[dsh-remote-web] 补记 bridge_secret 后重启 bridge 失败: ${e.message}`);
+      }
+    }, 50).unref?.();
+  }
+  return secret;
+}
+
+// ---------- v2 账号/配额/邀请代理（我的信息 与 免费额度提示） ----------
+
+/** token 获取失败的原因（供 UI 区分“未登录”与“中继未就绪”，不再一律谎报“尚未登录”）。 */
+const AUTH_NO_CREDENTIALS = "no_credentials";       // 本机没存账号/自建密钥 → 该去登录
+const AUTH_BAD_CREDENTIALS = "bad_credentials";     // 账号密码被企业端拒绝 → 该重新登录
+const AUTH_RELAY_UNREACHABLE = "relay_unreachable"; // 网络/5xx/超时 → 稍后重试
+const AUTH_RELAY_NOT_READY = "relay_not_ready";     // 凭证齐全但企业端未接受（缺失/轮换中的设备密钥等）→ 稍后重试
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/** 单次 device-login：返回 { ok, status, token, code, detail }（不抛错，便于按原因降级/重试）。 */
+async function deviceLoginOnce(api, cfg, secret) {
+  try {
+    const r = await fetch(`${api}/api/device-login`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...(secret ? { "x-dsh-bridge-secret": secret } : {}) },
+      body: JSON.stringify({ phone: cfg.phone, email: cfg.phone, password: cfg.password }),
+      signal: AbortSignal.timeout(6000)
+    });
+    const text = await r.text();
+    let d = null;
+    try { d = JSON.parse(text); } catch { d = null; }
+    return {
+      ok: r.ok,
+      status: r.status,
+      token: (d && d.token) || "",
+      code: (d && d.error && d.error.code) || "",
+      detail: (d && d.error && (d.error.message || d.error.code)) || "",
+    };
+  } catch (e) {
+    return { ok: false, status: 0, token: "", code: "", detail: e.message };
+  }
+}
+
+/** 单次本地认证（自建模式）：POST {隧道同源}/_login。 */
+async function localLoginOnce(cfg, api) {
+  const fallbackApi = (api || cfg.api_url || DEFAULT_API).replace(/\/+$/, "");
+  try {
+    const u = new URL(cfg.tunnel_url || fallbackApi.replace(/^https?/, "wss"));
     u.protocol = u.protocol === "wss:" ? "https:" : "http:";
     u.pathname = "/_login";
     const r = await fetch(u.toString(), {
@@ -629,20 +749,59 @@ async function relayToken(relayDir) {
       body: JSON.stringify({ key: cfg.local_key }),
       signal: AbortSignal.timeout(6000)
     });
-    if (!r.ok) return "";
+    if (!r.ok) return { ok: false, status: r.status, token: "", code: "", detail: "" };
     const d = await r.json();
-    return d.token || "";
+    return { ok: true, status: 200, token: (d && d.token) || "", code: "", detail: "" };
+  } catch (e) {
+    return { ok: false, status: 0, token: "", code: "", detail: e.message };
   }
-  if (!cfg.phone || !cfg.password) return "";
-  const r = await fetch(`${api}/api/device-login`, {
-    method: "POST",
-    headers: { "content-type": "application/json", ...(cfg.bridge_secret ? { "x-dsh-bridge-secret": cfg.bridge_secret } : {}) },
-    body: JSON.stringify({ phone: cfg.phone, email: cfg.phone, password: cfg.password }),
-    signal: AbortSignal.timeout(6000)
-  });
-  if (!r.ok) return "";
-  const d = await r.json();
-  return d.token || "";
+}
+
+/**
+ * 获取短期 relay token:SaaS → device-login;本地模式 → /_login(从隧道地址推导同源)。
+ * 与旧版差异：① 缺 device-login 共享密钥时自愈补齐；② 服务端轮换密钥(401/403)自动重取重试；
+ * ③ 网络抖动/5xx 退避重试一次；④ 失败时给出**可判定原因**而非空串（消除“尚未登录”误报）。
+ * @returns {Promise<{token:string, reason:string, status:number, detail:string}>}
+ */
+async function relayTokenWithReason(relayDir, cfgOverride) {
+  const cfg = cfgOverride && typeof cfgOverride === "object" ? { ...loadConfig(relayDir), ...cfgOverride } : loadConfig(relayDir);
+  const api = (cfg.api_url || DEFAULT_API).replace(/\/+$/, "");
+  if (cfg.local_key) {
+    let r = await localLoginOnce(cfg, api);
+    if (!r.token && (r.status === 0 || r.status >= 500)) { await sleep(350); r = await localLoginOnce(cfg, api); }
+    if (r.token) return { token: r.token, reason: "", status: r.status, detail: "" };
+    return {
+      token: "",
+      reason: r.status === 401 || r.status === 403 ? AUTH_BAD_CREDENTIALS : AUTH_RELAY_UNREACHABLE,
+      status: r.status,
+      detail: r.detail,
+    };
+  }
+  if (!cfg.phone || !cfg.password) return { token: "", reason: AUTH_NO_CREDENTIALS, status: 0, detail: "" };
+
+  let secret = await bridgeSecretOf(relayDir, cfgOverride);
+  let r = await deviceLoginOnce(api, cfg, secret);
+  // 带了密钥仍被拒 → 可能是服务端轮换了共享密钥：丢弃缓存强制重取一次再试
+  if (!r.token && (r.status === 401 || r.status === 403) && secret) {
+    const fresh = await bridgeSecretOf(relayDir, cfgOverride, { force: true });
+    if (fresh && fresh !== secret) r = await deviceLoginOnce(api, cfg, fresh);
+  }
+  // 网络抖动/超时/5xx：短退避重试一次（首次安装后中继握手偶发失败很常见）
+  if (!r.token && (r.status === 0 || r.status >= 500)) {
+    await sleep(350);
+    r = await deviceLoginOnce(api, cfg, await bridgeSecretOf(relayDir, cfgOverride));
+  }
+  if (r.token) return { token: r.token, reason: "", status: r.status, detail: "" };
+  if (r.code === "bad_credentials") return { token: "", reason: AUTH_BAD_CREDENTIALS, status: r.status, detail: r.detail };
+  // 凭证齐全但企业端没给 token（设备密钥缺失/轮换中、限流、其它 4xx）→ 可重试，不谎报“未登录”
+  if (r.status === 0 || r.status >= 500) return { token: "", reason: AUTH_RELAY_UNREACHABLE, status: r.status, detail: r.detail };
+  return { token: "", reason: AUTH_RELAY_NOT_READY, status: r.status, detail: r.detail };
+}
+
+/** 兼容旧调用方（反馈/账号/配额等只需 token 字符串）。 */
+async function relayToken(relayDir) {
+  const r = await relayTokenWithReason(relayDir).catch(() => ({ token: "" }));
+  return r.token || "";
 }
 
 /** 我的信息:SaaS 账号的生效套餐/到期日/邀请码(经 /api/me)。 */
@@ -722,6 +881,57 @@ function notLoggedInJson() {
   return { ok: false, error: "尚未登录：请先在「账号」卡片登录手机号账号（或切换到自建服务）后重试", hint: "login_required" };
 }
 
+/**
+ * 凭证齐全但拿不到 relay token 时的统一返回：区分「密码失效需重新登录」与「中继暂未就绪可重试」。
+ * 关键：不再把中继未就绪/设备密钥缺失谎报成“尚未登录”（旧版 UI 因此显示误导性红字）。
+ */
+function relayAuthFailureJson(reason, detail) {
+  if (reason === AUTH_NO_CREDENTIALS) return { status: 401, body: notLoggedInJson() };
+  if (reason === AUTH_BAD_CREDENTIALS) {
+    return {
+      status: 401,
+      body: {
+        ok: false,
+        error: "本机保存的账号密码已被中继拒绝（可能已在别处修改过密码）：请用新密码重新登录「账号」卡片后重试",
+        hint: "relogin_required",
+        retryable: false,
+        detail: String(detail || ""),
+      },
+    };
+  }
+  const unreachable = reason === AUTH_RELAY_UNREACHABLE;
+  return {
+    status: 503,
+    body: {
+      ok: false,
+      error: unreachable
+        ? "中继服务暂时不可达（网络波动或中继正在重启），请稍后重试"
+        : "账号已登录，但中继连接尚未就绪（正在建立安全通道），请稍后重试",
+      hint: unreachable ? "relay_unreachable" : "relay_not_ready",
+      retryable: true,
+      detail: String(detail || ""),
+    },
+  };
+}
+
+/**
+ * 取 relay token 或直接回错误响应（面板代理统一入口）。
+ * @returns {Promise<string>} token；为空串表示已写出错误响应（调用方直接 return）
+ */
+async function relayTokenOrReject(relayDir, res, cfgOverride) {
+  const a = await relayTokenWithReason(relayDir, cfgOverride).catch((e) => ({
+    token: "",
+    reason: AUTH_RELAY_UNREACHABLE,
+    status: 0,
+    detail: e && e.message,
+  }));
+  if (a.token) return a.token;
+  const { status, body } = relayAuthFailureJson(a.reason, a.detail);
+  console.warn(`[dsh-remote-web] 取 relay token 失败(${a.reason}/${a.status}): ${a.detail || "无详情"}`);
+  sendJson(res, status, body);
+  return "";
+}
+
 /**
  * 透传企业端响应体：契约字段可能在顶层或 data 子对象里（容错）。
  * 返回扁平对象；数组字段只取首层数组。
@@ -737,8 +947,8 @@ function flattenRelayBody(r) {
  * 契约容错：url 必须可用；qr_data_url 取不到时返回 null（UI 只展示链接并说明“二维码暂不可用”，不报错）。
  */
 async function proxyCreateAccessKey(relayDir, res) {
-  const token = await relayToken(relayDir).catch(() => "");
-  if (!token) return sendJson(res, 401, notLoggedInJson());
+  const token = await relayTokenOrReject(relayDir, res);
+  if (!token) return;
   const r = await relayFetch(relayDir, "/api/auth-key", {
     method: "POST",
     headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
@@ -766,8 +976,8 @@ async function proxyCreateAccessKey(relayDir, res) {
  * GET /dsh-remote/mobile-sessions → 已授权设备列表（企业端 GET /api/mobile-sessions，Bearer）。
  */
 async function proxyMobileSessions(relayDir, res) {
-  const token = await relayToken(relayDir).catch(() => "");
-  if (!token) return sendJson(res, 401, notLoggedInJson());
+  const token = await relayTokenOrReject(relayDir, res);
+  if (!token) return;
   const r = await relayFetch(relayDir, "/api/mobile-sessions", {
     method: "GET",
     headers: { authorization: `Bearer ${token}` },
@@ -788,8 +998,8 @@ async function proxyRevokeMobileSession(relayDir, req, res) {
   if (body.__parseError) return sendJson(res, 400, { ok: false, error: "JSON 解析失败" });
   const id = String(body.id ?? "").trim();
   if (!id) return sendJson(res, 400, { ok: false, error: "缺少参数 id（会话 ID）" });
-  const token = await relayToken(relayDir).catch(() => "");
-  if (!token) return sendJson(res, 401, notLoggedInJson());
+  const token = await relayTokenOrReject(relayDir, res);
+  if (!token) return;
   const r = await relayFetch(relayDir, `/api/mobile-sessions/${encodeURIComponent(id)}/revoke`, {
     method: "POST",
     headers: { authorization: `Bearer ${token}` },
@@ -812,8 +1022,8 @@ async function proxyDeleteMobileSession(relayDir, req, res) {
   if (body.__parseError) return sendJson(res, 400, { ok: false, error: "JSON 解析失败" });
   const id = String(body.id ?? "").trim();
   if (!id) return sendJson(res, 400, { ok: false, error: "缺少参数 id（会话 ID）" });
-  const token = await relayToken(relayDir).catch(() => "");
-  if (!token) return sendJson(res, 401, notLoggedInJson());
+  const token = await relayTokenOrReject(relayDir, res);
+  if (!token) return;
   const r = await relayFetch(relayDir, `/api/mobile-sessions/${encodeURIComponent(id)}`, {
     method: "DELETE",
     headers: { authorization: `Bearer ${token}` },
@@ -831,8 +1041,8 @@ async function proxyDeleteMobileSession(relayDir, req, res) {
  * （企业端 POST /api/mobile-sessions/purge，Bearer）。
  */
 async function proxyPurgeMobileSessions(relayDir, res) {
-  const token = await relayToken(relayDir).catch(() => "");
-  if (!token) return sendJson(res, 401, notLoggedInJson());
+  const token = await relayTokenOrReject(relayDir, res);
+  if (!token) return;
   const r = await relayFetch(relayDir, "/api/mobile-sessions/purge", {
     method: "POST",
     headers: { authorization: `Bearer ${token}` },
@@ -1030,7 +1240,7 @@ const PLUGIN_ID = "dsh-remote-web";
 const PLUGIN_LEGACY_IDS = ["dsh-remote-ui"];
 const PLUGIN_ALL_IDS = [PLUGIN_ID, ...PLUGIN_LEGACY_IDS];
 /** 插件自身发布版本（与 dsh-remote 根包同步递增）。 */
-const PLUGIN_VERSION = "0.6.0";
+const PLUGIN_VERSION = "0.6.1-beta.1";
 const UPDATE_LOG = ".dsh-update.log";
 const UPDATE_MARKER = ".dsh-update-running";
 
@@ -1352,6 +1562,14 @@ function registerRoutes(ctx, relayDir) {
           }
           // SaaS 权威归一化：清除自建残留(local_key/假 tunnel_url)，api/tunnel 一律按云端重算
           applySaaSMode(cfg);
+          // device-login 共享密钥自愈：只装插件的路径没有安装器那一步，缺密钥会导致
+          // 「首次安装后立即登录」时面板拿不到二维码/设备列表（旧版要等后台自愈或手动刷新）。
+          // 这里在启动 bridge 之前补齐，bridge 首次启动即可带上密钥。
+          if (!cfg.bridge_secret) {
+            // 3s 上限：这次取密钥在登录响应路径上，宁可先放行（后续请求还会自愈）也不拖慢登录
+            const secret = await bridgeSecretOf(relayDir, cfg, { timeoutMs: 3000 });
+            if (secret) cfg.bridge_secret = secret;
+          }
         }
         saveConfig(relayDir, cfg);
         const bridgeRestart = startBridge(relayDir);

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

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.5.0",
+  "version": "0.6.1-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",
@@ -40,4 +40,4 @@
   },
   "homepage": "https://github.com/mrRisega/dsh-remote/tree/main/packages/dsh-remote-web#readme",
   "license": "PolyForm-Noncommercial-1.0.0"
-}
+}

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

@@ -0,0 +1,247 @@
+// 首次安装后「立即登录」二维码/设备列表报红字 的回归（node 半）。
+//
+// 现场：全新安装只装插件（dsh plugin add / 插件市场）时，.dsh-config.json 里没有 bridge_secret
+// （该字段原本只有一键安装器 dsh-setup.mjs 会写）。而企业端 POST /api/device-login 强制校验
+// x-dsh-bridge-secret → 面板请求 /dsh-remote/access-key & /dsh-remote/mobile-sessions 时拿不到 token，
+// 旧版一律回 401「尚未登录：请先在「账号」卡片登录手机号账号」——用户明明刚登录成功（误导性红字），
+// 只能等后台自愈装完运行环境写回密钥、或手动刷新页面才恢复。
+//
+// 本用例锁死四点：
+//   1. 缺 bridge_secret → 插件向 /api/public-config 自愈取一次并落盘，请求一次即成功（无需刷新）；
+//   2. 带了密钥仍失败（网络/5xx）→ 服务端退避重试一次；
+//   3. 服务端轮换密钥 → 强制重取新密钥再试；
+//   4. 凭证齐全却拿不到 token → 503 + retryable（绝不再谎报“尚未登录”）；密码失效 → 401 relogin_required。
+import assert from "node:assert/strict";
+import http from "node:http";
+import { mkdtemp, readFile, 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";
+
+const SECRET = "secret-aaa-111";
+const NEW_SECRET = "secret-bbb-222";
+const EXPIRES = 1893456000000;
+
+/**
+ * 假企业端（复刻生产行为）：
+ *  - GET /api/public-config：下发 bridge_secret（可关闭/可轮换）
+ *  - POST /api/device-login：**强制**校验 x-dsh-bridge-secret，缺失/不符 → 401 需要有效设备密钥
+ *  - POST /api/auth-key：需 Bearer → 返回一次性访问地址与二维码
+ */
+function startFakeRelay(opts = {}) {
+  const seen = [];
+  let secret = opts.secret === undefined ? SECRET : opts.secret;
+  let deviceLoginCalls = 0;
+  const srv = http.createServer(async (req, res) => {
+    const url = new URL(req.url, "http://x");
+    const send = (code, obj) => {
+      res.writeHead(code, { "content-type": "application/json" });
+      res.end(JSON.stringify(obj));
+    };
+    seen.push({
+      method: req.method,
+      path: url.pathname,
+      authorization: req.headers.authorization || "",
+      secret: req.headers["x-dsh-bridge-secret"] || "",
+    });
+    if (req.method === "GET" && url.pathname === "/api/public-config") {
+      if (opts.noPublicConfig) return send(503, { error: { message: "public-config down" } });
+      return send(200, { service: "dsh-remote", app_url: "https://app.test/", api_url: `http://127.0.0.1:${srv.address().port}`, bridge_secret: secret });
+    }
+    if (req.method === "POST" && url.pathname === "/api/device-login") {
+      deviceLoginCalls += 1;
+      // 前 N 次网络/5xx 类失败（模拟中继刚重启）
+      if (opts.deviceLoginFailTimes && deviceLoginCalls <= opts.deviceLoginFailTimes) {
+        if (opts.deviceLoginFailMode === "throw") { req.socket.destroy(); return; }
+        return send(503, { error: { code: "unavailable", message: "中继重启中" } });
+      }
+      if (opts.badCredentials) return send(401, { error: { code: "bad_credentials", message: "手机号或密码错误" } });
+      const got = req.headers["x-dsh-bridge-secret"] || "";
+      if (!secret || got !== secret) return send(401, { error: { code: "unauthorized", message: "device-login 需要有效设备密钥" } });
+      return send(200, { token: "jwt-abc" });
+    }
+    if (req.method === "POST" && url.pathname === "/api/auth-key") {
+      if (!(req.headers.authorization || "").startsWith("Bearer ")) return send(401, { error: { code: "invalid_token", message: "无效或过期的 token" } });
+      return send(200, { ok: true, key: "K1", url: "https://app.test/a/K1", expires_at: EXPIRES, ttl_ms: 1800000, qr_data_url: "data:image/png;base64,AAAA" });
+    }
+    if (req.method === "GET" && url.pathname === "/api/mobile-sessions") {
+      if (!(req.headers.authorization || "").startsWith("Bearer ")) return send(401, { error: { code: "invalid_token", message: "无效或过期的 token" } });
+      return send(200, { ok: true, sessions: [{ id: "ms_1", label: "iPhone 15", created_at: 1700000000000, revoked_at: null }] });
+    }
+    send(404, { error: { code: "not_found" } });
+  });
+  return new Promise((resolve) => srv.listen(0, "127.0.0.1", () => resolve({
+    srv, seen, port: srv.address().port,
+    rotateSecret(next) { secret = next === undefined ? NEW_SECRET : next; },
+    getSecret() { return secret; },
+  })));
+}
+
+/** 装载插件路由（boot），cfgExtra 覆盖默认配置。 */
+async function bootRelay(relayPort, cfgExtra = {}, relayDirOverride) {
+  const tempDir = relayDirOverride || (await mkdtemp(path.join(os.tmpdir(), "dsh-first-login-")));
+  await writeFile(path.join(tempDir, ".dsh-config.json"), JSON.stringify({
+    phone: "13800000000",
+    password: "pw",
+    device_id: "dev-first-login",
+    api_url: `http://127.0.0.1:${relayPort}`,
+    ...cfgExtra,
+  }));
+  const routes = new Map();
+  apply({
+    webServer: { register(route) { routes.set(route.path, route.handler); return () => {}; } },
+    effect(register) { return register(); },
+    logger: { info() {}, warn() {} },
+  }, { relayDir: tempDir });
+  const host = http.createServer((req, res) => {
+    const url = new URL(req.url, "http://x");
+    const handler = routes.get(url.pathname);
+    (handler || ((_r, rs) => { rs.writeHead(404); rs.end(); }))(req, res);
+  });
+  await new Promise((resolve) => host.listen(0, "127.0.0.1", resolve));
+  return { host, base: `http://127.0.0.1:${host.address().port}`, tempDir };
+}
+
+async function readCfg(dir) {
+  return JSON.parse(await readFile(path.join(dir, ".dsh-config.json"), "utf8"));
+}
+
+test("首次安装（配置缺 bridge_secret）→ 自愈取密钥并落盘：二维码一次就拿到，不再需要刷新页面", async () => {
+  const relay = await startFakeRelay();
+  const { host, base, tempDir } = await bootRelay(relay.port); // 无 bridge_secret：模拟只装插件的全新安装
+  try {
+    const res = await fetch(`${base}/dsh-remote/access-key`);
+    assert.equal(res.status, 200, "首次登录后应立即拿到一次性访问地址（旧版这里 401「尚未登录」）");
+    const r = await res.json();
+    assert.equal(r.ok, true);
+    assert.equal(r.url, "https://app.test/a/K1");
+    assert.equal(r.qr_data_url, "data:image/png;base64,AAAA", "二维码应随首次请求一起返回");
+
+    const dl = relay.seen.filter((s) => s.path === "/api/device-login");
+    assert.equal(dl.length, 1, "device-login 只应调用一次（自愈取到密钥后再发请求）");
+    assert.equal(dl[0].secret, SECRET, "device-login 必须带上自愈得到的共享密钥");
+    assert.equal((await readCfg(tempDir)).bridge_secret, SECRET, "密钥应落盘，供 bridge 与后续重启复用");
+  } finally {
+    host.close();
+    relay.srv.close();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("设备列表同样自愈：缺 bridge_secret 时 mobile-sessions 一次成功", async () => {
+  const relay = await startFakeRelay();
+  const { host, base, tempDir } = await bootRelay(relay.port);
+  try {
+    const res = await fetch(`${base}/dsh-remote/mobile-sessions`);
+    assert.equal(res.status, 200);
+    const r = await res.json();
+    assert.equal(r.ok, true);
+    assert.equal(r.sessions.length, 1);
+    assert.equal(r.sessions[0].label, "iPhone 15");
+  } finally {
+    host.close();
+    relay.srv.close();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("有密钥但中继 5xx（刚重启）→ 服务端退避重试一次即成功", async () => {
+  const relay = await startFakeRelay({ deviceLoginFailTimes: 1 });
+  const { host, base, tempDir } = await bootRelay(relay.port, { bridge_secret: SECRET });
+  try {
+    const res = await fetch(`${base}/dsh-remote/access-key`);
+    assert.equal(res.status, 200, "中继抖动一次应被服务端重试吸收");
+    assert.equal(relay.seen.filter((s) => s.path === "/api/device-login").length, 2, "应重试一次");
+  } finally {
+    host.close();
+    relay.srv.close();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("网络层失败（连接被断开）→ 服务端重试一次", async () => {
+  const relay = await startFakeRelay({ deviceLoginFailTimes: 1, deviceLoginFailMode: "throw" });
+  const { host, base, tempDir } = await bootRelay(relay.port, { bridge_secret: SECRET });
+  try {
+    const res = await fetch(`${base}/dsh-remote/mobile-sessions`);
+    assert.equal(res.status, 200, "连接抖动（fetch 抛错）也应重试后成功");
+  } finally {
+    host.close();
+    relay.srv.close();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("服务端轮换 shared secret → 强制重取新密钥再试，且写回配置", async () => {
+  const relay = await startFakeRelay({ secret: SECRET });
+  const { host, base, tempDir } = await bootRelay(relay.port, { bridge_secret: "secret-stale-999" });
+  try {
+    relay.rotateSecret(NEW_SECRET); // 企业端换了密钥，本机还存着旧的
+    const res = await fetch(`${base}/dsh-remote/access-key`);
+    assert.equal(res.status, 200, "旧密钥被拒后应自动取新密钥重试");
+    assert.equal((await readCfg(tempDir)).bridge_secret, NEW_SECRET, "新密钥应覆盖写回配置");
+    const secrets = relay.seen.filter((s) => s.path === "/api/device-login").map((s) => s.secret);
+    assert.deepEqual(secrets, ["secret-stale-999", NEW_SECRET], "先旧后新：第二次必须用轮换后的密钥");
+  } finally {
+    host.close();
+    relay.srv.close();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("凭证齐全但中继未就绪（重试后仍失败）→ 503 + retryable，绝不谎报「尚未登录」", async () => {
+  const relay = await startFakeRelay({ noPublicConfig: true }); // 取不到密钥 → device-login 401 需要设备密钥
+  const { host, base, tempDir } = await bootRelay(relay.port);
+  try {
+    const res = await fetch(`${base}/dsh-remote/access-key`);
+    assert.equal(res.status, 503, "应回可重试状态码，而不是 401");
+    const r = await res.json();
+    assert.equal(r.ok, false);
+    assert.equal(r.retryable, true, "必须标记 retryable，浏览器半据此自动重试");
+    assert.equal(r.hint, "relay_not_ready");
+    assert.ok(!/尚未登录/.test(String(r.error)), "账号已登录，文案不得再引导用户去登录");
+    assert.match(String(r.error), /尚未就绪|稍后重试/);
+  } finally {
+    host.close();
+    relay.srv.close();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("密码被企业端拒绝 → 401 relogin_required（不可重试，提示重新登录）", async () => {
+  const relay = await startFakeRelay({ badCredentials: true });
+  const { host, base, tempDir } = await bootRelay(relay.port, { bridge_secret: SECRET });
+  try {
+    const res = await fetch(`${base}/dsh-remote/mobile-sessions`);
+    assert.equal(res.status, 401);
+    const r = await res.json();
+    assert.equal(r.hint, "relogin_required");
+    assert.equal(r.retryable, false, "密码失效重试无意义");
+    assert.match(String(r.error), /重新登录/);
+    assert.ok(!/尚未登录/.test(String(r.error)), "与「未登录」分开，文案要能指导下一步");
+  } finally {
+    host.close();
+    relay.srv.close();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("自建模式不取设备密钥（走 /_login，不经 public-config）", async () => {
+  const relay = await startFakeRelay();
+  // 自建：local_key 优先于账号（假企业端未实现 /_login → 降级失败，但绝不能去 device-login/public-config）
+  const { host, base, tempDir } = await bootRelay(relay.port, {
+    local_key: "lk-1",
+    tunnel_url: `ws://127.0.0.1:${relay.port}`,
+  });
+  try {
+    const res = await fetch(`${base}/dsh-remote/access-key`);
+    assert.equal(res.status, 503, "自建且上游未实现 /_login → 可重试降级");
+    assert.ok(!relay.seen.some((s) => s.path === "/api/device-login" || s.path === "/api/public-config"),
+      "自建模式不得请求 device-login / public-config");
+  } finally {
+    host.close();
+    relay.srv.close();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,307 @@
+// 首次安装后「立即登录」面板自愈 的回归（浏览器半，真实 useEffect + 假定时器）。
+//
+// 现场：登录成功（loggedIn 翻真）后，面板立刻请求二维码与已授权设备列表；此时中继握手可能还没就绪
+// （bridge 刚被重启、device-login 共享密钥刚补齐/正在轮换），旧版只显示一次红字、**不重试**，
+// 必须手动刷新页面才恢复。本用例锁死新的自愈行为：
+//   ① 登录后自动发起 access-key + mobile-sessions；
+//   ② 首次失败(503 retryable) → 黄字「自动重试」+「立即重试」按钮（不吓人、可操作）；
+//   ③ 退避到点自动重试 → 成功即自动清除提示、渲染二维码与设备列表（无需刷新页面）；
+//   ④ 未登录时绝不请求企业端、也不出现误导性红字。
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+import vm from "node:vm";
+
+const SOURCE = readFileSync(new URL("../lib/client.js", import.meta.url), "utf8");
+
+function walk(node, visit) {
+  if (node == null) return;
+  if (Array.isArray(node)) { for (const item of node) walk(item, visit); return; }
+  if (typeof node !== "object") return;
+  visit(node);
+  for (const child of node.children || []) walk(child, visit);
+}
+function find(tree, predicate) {
+  let match;
+  walk(tree, (node) => { if (!match && predicate(node)) match = node; });
+  return match;
+}
+function textHas(tree, substr) {
+  return !!find(tree, (node) => (node.children || []).some((c) => typeof c === "string" && c.includes(substr)));
+}
+/** 取包含某文案的节点（用于点它的 onClick）。 */
+function nodeWithText(tree, substr) {
+  return find(tree, (node) => typeof node.props?.onClick === "function" && (node.children || []).some((c) => typeof c === "string" && c.includes(substr)));
+}
+
+const flush = () => new Promise((resolve) => setImmediate(resolve));
+const NOT_LOGGED = { ok: true, config: { phone: "", hasPhone: false, mode: "saas", deviceId: "dev-x" }, service: { running: false }, remoteUrl: "https://app.test/" };
+const LOGGED = { ok: true, config: { phone: "138****0000", hasPhone: true, mode: "saas", deviceId: "dev-x" }, service: { running: true }, remoteUrl: "https://app.test/" };
+const KEY_URL = "https://app.test/a/K1";
+const SESSIONS = [{ id: "ms_1", label: "iPhone 15", os: "iOS", browser: "Safari", created_at: 1700000000000, last_seen_at: 1700000600000, revoked_at: null }];
+
+/**
+ * 迷你 React（真实 useEffect：依赖比较 + 提交后执行 + cleanup）+ 可控假定时器。
+ * @param {object} opts - { failAccessKey:[次数], failSessions:[次数], status: 状态响应 }
+ */
+function loadPlugin(opts = {}) {
+  let moduleFactory;
+  const registered = new Map();
+  const injects = new Map();
+  const requests = [];
+  const states = [];
+  let hook = 0;
+  let effectCursor = 0;
+  let effectSlots = [];
+  let pending = [];
+
+  // ── 假定时器（可精确推进退避窗口） ──
+  let clock = 0;
+  let timerSeq = 1;
+  const timers = new Map();
+  const job = (fn) => { try { fn(); } catch (e) { /* 忽略：被测代码内部错误由断言暴露 */ } };
+  const fakeSetTimeout = (fn, ms) => { const id = timerSeq++; timers.set(id, { at: clock + (Number(ms) || 0), fn, every: 0 }); return id; };
+  const fakeSetInterval = (fn, ms) => { const id = timerSeq++; const every = Math.max(1, Number(ms) || 1); timers.set(id, { at: clock + every, fn, every }); return id; };
+  const fakeClear = (id) => { timers.delete(id); };
+  async function advance(ms) {
+    const target = clock + ms;
+    for (let guard = 0; guard < 400; guard++) {
+      let due = null;
+      for (const [id, t] of timers) if (t.at <= target && (!due || t.at < due[1].at)) due = [id, t];
+      if (!due) break;
+      const [id, t] = due;
+      clock = t.at;
+      if (t.every) t.at = clock + t.every; else timers.delete(id);
+      job(t.fn);
+      await flush(); await flush();
+    }
+    clock = target;
+    await flush(); await flush();
+  }
+
+  const react = {
+    createElement(type, props, ...children) { return { type, props: props || {}, children }; },
+    useState(initial) {
+      const index = hook++;
+      if (!(index in states)) states[index] = typeof initial === "function" ? initial() : initial;
+      return [states[index], (value) => { states[index] = typeof value === "function" ? value(states[index]) : value; }];
+    },
+    useEffect(fn, deps) {
+      const index = effectCursor++;
+      const prev = effectSlots[index];
+      const changed = !prev || !deps || deps.length !== prev.deps.length || deps.some((d, i) => !Object.is(d, prev.deps[i]));
+      if (changed) pending.push({ index, fn, deps: deps ? [...deps] : deps });
+    },
+    useCallback(fn) { return fn; },
+    useSyncExternalStore(_subscribe, getSnapshot) { return getSnapshot(); },
+  };
+
+  // 企业端代理响应：可控失败次数 + 默认成功
+  let statusBody = opts.status || NOT_LOGGED;
+  let keyFails = opts.failAccessKey || 0;
+  let sessFails = opts.failSessions || 0;
+  let keyCalls = 0;
+  let sessCalls = 0;
+  const response = (status, body) => Promise.resolve({
+    ok: status >= 200 && status < 300,
+    status,
+    text: async () => JSON.stringify(body),
+  });
+  const NOT_READY = opts.failBody || { ok: false, error: "账号已登录，但中继连接尚未就绪（正在建立安全通道），请稍后重试", hint: "relay_not_ready", retryable: true };
+  const FAIL_STATUS = opts.failStatus || 503;
+
+  const makeEl = () => ({
+    tag: "div", children: [], style: {}, className: "", attributes: {}, textContent: "",
+    setAttribute(k, v) { this.attributes[k] = v; },
+    getAttribute(k) { return this.attributes[k] ?? null; },
+    appendChild(c) { this.children.push(c); },
+    addEventListener() {}, removeEventListener() {},
+  });
+  const doc = {
+    hidden: false,
+    createElement: makeEl,
+    head: makeEl(),
+    body: makeEl(),
+    querySelector() { return null; },
+    querySelectorAll() { return []; },
+    getElementById() { return null; },
+    addEventListener() {}, removeEventListener() {},
+  };
+  class MutationObserverMock { constructor() {} observe() {} disconnect() {} }
+  const localStorage = {
+    _s: new Map(),
+    getItem(k) { return this._s.has(k) ? this._s.get(k) : null; },
+    setItem(k, v) { this._s.set(k, String(v)); },
+    removeItem(k) { this._s.delete(k); },
+  };
+
+  const sandbox = {
+    window: { __ModuleLoader__: { load(spec) { moduleFactory = spec.factory; } }, open() { return null; } },
+    document: doc,
+    localStorage,
+    MutationObserver: MutationObserverMock,
+    navigator: { clipboard: { writeText: async () => {} } },
+    setTimeout: fakeSetTimeout,
+    clearTimeout: fakeClear,
+    setInterval: fakeSetInterval,
+    clearInterval: fakeClear,
+    fetch(path, options = {}) {
+      requests.push({ path, method: options.method || "GET" });
+      if (path === "/dsh-remote/status") return response(200, statusBody);
+      if (path === "/dsh-remote/access-key") {
+        keyCalls += 1;
+        if (keyCalls <= keyFails) return response(FAIL_STATUS, NOT_READY);
+        return response(200, { ok: true, url: KEY_URL, key: "K1", expires_at: Date.now() + 1800000, ttl_ms: 1800000, qr_data_url: "data:image/png;base64,AAAA" });
+      }
+      if (path === "/dsh-remote/mobile-sessions") {
+        sessCalls += 1;
+        if (sessCalls <= sessFails) return response(FAIL_STATUS, NOT_READY);
+        return response(200, { ok: true, sessions: SESSIONS });
+      }
+      if (path === "/dsh-remote/account") return response(200, { ok: true, account: { phone: "138****0000", plan: "free", plan_source: "plan" } });
+      if (path === "/dsh-remote/quota") return response(200, { ok: true, quota: null });
+      if (path === "/dsh-remote/remote-url") return response(200, { ok: true, remoteUrl: "https://app.test/", publicConfig: {} });
+      return response(200, { ok: true });
+    },
+    Set, Symbol, Date, JSON, Math, Number, String, Object, Array, console,
+  };
+
+  vm.runInNewContext(SOURCE, sandbox);
+  const plugin = moduleFactory((name) => {
+    assert.equal(name, "react");
+    return react;
+  });
+  plugin.apply({
+    slots: {
+      inject(name, cb) { injects.set(name, cb); cb(); },
+      register(meta, component) { registered.set(meta.id, component); return () => {}; },
+    },
+  });
+
+  return {
+    requests,
+    states,
+    /** 渲染一轮并执行本轮需要运行的 effects（含 cleanup）。 */
+    render() {
+      hook = 0; effectCursor = 0; pending = [];
+      const tree = registered.get("dsh-remote")({ close() {} });
+      const todos = pending; pending = [];
+      for (const t of todos) {
+        const prev = effectSlots[t.index];
+        if (prev && typeof prev.cleanup === "function") job(prev.cleanup);
+        const cleanup = t.fn();
+        effectSlots[t.index] = { deps: t.deps, cleanup: typeof cleanup === "function" ? cleanup : null };
+      }
+      return tree;
+    },
+    advance,
+    /** 渲染 → 让在途请求落地 → 再渲染（返回最新树），模拟真实的重渲染节奏。 */
+    async settle(times = 2) {
+      let tree = null;
+      for (let i = 0; i < times; i++) {
+        tree = this.render();
+        await flush(); await flush();
+      }
+      return this.render();
+    },
+    /** 模拟「账号登录成功」：改写状态响应 + 推进 30s 轮询心跳，让面板看到登录态。 */
+    async login() {
+      statusBody = LOGGED;
+      await advance(30_000);
+      return this.settle();
+    },
+    counts() { return { keyCalls, sessCalls }; },
+  };
+}
+
+test("未登录：不请求企业端、不出误导性红字；登录后自动拉取二维码与设备列表", async () => {
+  const plugin = loadPlugin();
+  let tree = await plugin.settle(); // 挂载 → refresh() 读状态
+
+  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, "登录下方「🔑 账号」卡片中的手机号账号后"), "未登录应给登录引导而非报错");
+  assert.ok(!textHas(tree, "尚未登录"), "未登录也不该出现接口报错红字");
+
+  tree = await plugin.login();
+  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(find(tree, (n) => n.props?.src === "data:image/png;base64,AAAA"), "登录后应直接渲染二维码");
+});
+
+test("登录瞬间中继未就绪：首次失败自动重试，退避到点即恢复（无需刷新页面）", async () => {
+  const plugin = loadPlugin({ failAccessKey: 1, failSessions: 1 });
+  let tree = await plugin.settle();
+  tree = await plugin.login();
+
+  // 首次失败：黄字提示 + 可点的「立即重试」，而不是死红字（旧版行为）
+  assert.equal(plugin.counts().keyCalls, 1, "登录后第一次请求二维码");
+  assert.equal(plugin.counts().sessCalls, 1, "登录后第一次请求设备列表");
+  assert.ok(textHas(tree, "中继连接尚未就绪"), "失败应给「中继连接尚未就绪」的可重试提示");
+  assert.ok(textHas(tree, "秒后自动重试"), "应说明会自动重试");
+  assert.ok(nodeWithText(tree, "立即重试"), "提示旁应提供「立即重试」按钮");
+  assert.ok(!find(tree, (n) => n.props?.src === "data:image/png;base64,AAAA"), "首次失败时还没有二维码");
+
+  // 退避 1.2s 后自动重试 → 成功 → 提示清除、二维码与设备列表就位
+  await plugin.advance(1300);
+  assert.equal(plugin.counts().keyCalls, 2, "退避到点应自动重试二维码");
+  assert.equal(plugin.counts().sessCalls, 2, "退避到点应自动重试设备列表");
+
+  tree = await plugin.settle();
+  assert.ok(find(tree, (n) => n.props?.src === "data:image/png;base64,AAAA"), "重试成功后应渲染二维码");
+  assert.ok(textHas(tree, "已授权设备 1"), "重试成功后设备列表应加载完成（无需手动展开/刷新）");
+  assert.ok(!textHas(tree, "中继连接尚未就绪"), "成功后应自动清除重试提示");
+  assert.ok(!textHas(tree, "加载已授权设备失败"), "成功路径上不得残留红字错误");
+});
+
+test("点「立即重试」：不等退避窗口，立刻重发并恢复", async () => {
+  const plugin = loadPlugin({ failAccessKey: 1, failSessions: 1 });
+  await plugin.settle();
+  const tree0 = await plugin.login();
+  assert.equal(plugin.counts().keyCalls, 1);
+
+  const retryBtn = nodeWithText(tree0, "立即重试");
+  assert.ok(retryBtn, "应能找到「立即重试」按钮");
+  retryBtn.props.onClick();
+  const tree = await plugin.settle();
+
+  assert.equal(plugin.counts().keyCalls, 2, "手动重试应立即重发二维码请求");
+  assert.ok(find(tree, (n) => n.props?.src === "data:image/png;base64,AAAA"), "手动重试后应渲染二维码");
+});
+
+test("持续失败：退避重试上限后停在红字并保留「立即重试」，不无限刷请求", async () => {
+  const plugin = loadPlugin({ failAccessKey: 99, failSessions: 99 });
+  await plugin.settle();
+  await plugin.login();
+  await plugin.advance(2000);   // 第 1 次自动重试
+  await plugin.advance(4000);   // 第 2 次
+  await plugin.advance(8000);   // 第 3 次
+  await plugin.advance(60_000); // 之后不再自动重试（除 25s 轮换）
+  const after = plugin.counts();
+  assert.ok(after.sessCalls <= 4, `设备列表重试应有上限（实际 ${after.sessCalls}）`);
+  const tree = await plugin.settle();
+  assert.ok(nodeWithText(tree, "立即重试"), "失败后应保留可操作的重试入口");
+});
+
+test("不可重试失败（401 密码失效 / 未登录）：直接红字提示，不做无意义重试", async () => {
+  const plugin = loadPlugin({
+    failAccessKey: 99,
+    failSessions: 99,
+    failStatus: 401,
+    failBody: { ok: false, error: "本机保存的账号密码已被中继拒绝：请用新密码重新登录", hint: "relogin_required", retryable: false },
+  });
+  await plugin.settle();
+  await plugin.login();
+  assert.equal(plugin.counts().sessCalls, 1);
+
+  await plugin.advance(10_000); // 远超退避窗口（但短于 25s 的二维码周期轮换）
+  assert.equal(plugin.counts().sessCalls, 1, "不可重试类失败不得自动重发（设备列表）");
+  assert.equal(plugin.counts().keyCalls, 1, "不可重试类失败不得自动重发（二维码）");
+  await plugin.advance(20_000); // 25s 轮换后设备列表仍不自动重发（仅二维码按周期换新）
+  assert.equal(plugin.counts().sessCalls, 1, "设备列表没有周期轮换，失败后不得空转");
+
+  const tree = await plugin.settle();
+  assert.ok(textHas(tree, "加载已授权设备失败：本机保存的账号密码已被中继拒绝"), "应显示真实原因红字");
+  assert.ok(textHas(tree, "获取一次性访问地址失败：本机保存的账号密码已被中继拒绝"), "二维码卡同样显示真实原因");
+  assert.ok(!textHas(tree, "秒后自动重试"), "不可重试时不应出现自动重试提示");
+});